@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/i18next-BEJgv_S8.js

@@ -0,0 +1,1596 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { t as pluralCategories } from "./validate-BxpupdAf.js";
+import { n as printICU } from "./codec-DuvU2VQy.js";
+import { l as langFromId, u as parseModule } from "./worker-84U6uYB3.js";
+import { _ as keyName, a as attributeExpression, b as stringValue, c as cleanJsxText, d as isNode, f as jsString, g as jsxNameNodes, h as jsxName, i as analyzeModule, l as identifierName, m as jsxChildren, 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-EsIw_lsq.js";
+import { extname } from "node:path";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+//#region src/cli/commands/migrate/formats.ts
+/**
+* Catalog formats of the libraries `vi18n migrate` converts from (INTERNALS
+* §2.14): nested JSON flattened to keys, a YAML subset for vue-i18n (vi18n
+* depends on no YAML parser, §6 D1), FormatJS's compiled message AST, and the
+* id schemes of FormatJS and Lingui, so translations keyed by a generated id
+* are found from the message text a call site holds. Every reader reports
+* what it cannot read instead of guessing; nothing here executes a catalog.
+*/
+/** 1-based line of an offset. */
+function lineAt(text, offset) {
+	let line = 1;
+	for (let i = text.indexOf("\n"); i !== -1 && i < offset; i = text.indexOf("\n", i + 1)) line++;
+	return line;
+}
+/** `JSON.parse`, with the position of a syntax error turned into a line. */
+function parseJson(text) {
+	const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	try {
+		return {
+			value: JSON.parse(body),
+			problem: null
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const at = /position (\d+)/.exec(message);
+		return {
+			value: void 0,
+			problem: {
+				message,
+				line: at === null ? 0 : lineAt(body, Number(at[1]))
+			}
+		};
+	}
+}
+/** The line of each key's first occurrence in a JSON text (`"key":`), for diagnostics. */
+function keyLines(text) {
+	const lines = /* @__PURE__ */ new Map();
+	const pattern = /"((?:[^"\\\n]|\\.)*)"\s*:/g;
+	for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+		let key;
+		try {
+			key = JSON.parse(`"${match[1]}"`);
+		} catch {
+			continue;
+		}
+		if (!lines.has(key)) lines.set(key, lineAt(text, match.index));
+	}
+	return lines;
+}
+/**
+* Flattens a nested catalog: objects join their keys with `separator`,
+* arrays use indexes (`list.0`), as i18next and vue-i18n address them.
+* Leaves that are not strings are reported, never stringified.
+*/
+function flattenTree(tree, text, separator = ".") {
+	const texts = /* @__PURE__ */ new Map();
+	const problems = [];
+	const lines = keyLines(text);
+	const lineOf = (key) => {
+		const last = key.lastIndexOf(separator);
+		return lines.get(key) ?? lines.get(last === -1 ? key : key.slice(last + 1)) ?? 0;
+	};
+	const visit = (value, key) => {
+		if (typeof value === "string") {
+			texts.set(key, {
+				value,
+				line: lineOf(key)
+			});
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item, index) => visit(item, key === "" ? String(index) : `${key}${separator}${index}`));
+			return;
+		}
+		if (typeof value === "object" && value !== null) {
+			for (const [name, item] of Object.entries(value)) visit(item, key === "" ? name : `${key}${separator}${name}`);
+			return;
+		}
+		if (value === null) return;
+		problems.push({
+			message: `"${key}" holds ${typeof value} ${JSON.stringify(value)}, not a string; it was skipped`,
+			line: lineOf(key)
+		});
+	};
+	if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+		problems.push({
+			message: "a catalog is an object of messages",
+			line: 1
+		});
+		return {
+			texts,
+			problems
+		};
+	}
+	visit(tree, "");
+	return {
+		texts,
+		problems
+	};
+}
+var YamlError = class extends Error {
+	line;
+	constructor(message, line) {
+		super(message);
+		this.line = line;
+	}
+};
+/**
+* Block mappings and sequences of scalars: plain, quoted (single and double,
+* also over several lines) and block scalars (`|`, `>`, with chomping and an
+* indentation indicator); comments; `{}` and `[]`. Anchors, aliases, tags,
+* non-empty flow collections and complex keys are errors, since guessing
+* would change a message silently. Plain scalars stay strings (`404`, `yes`):
+* a message catalog has nothing else.
+*/
+function parseYaml(text) {
+	const lines = (text.charCodeAt(0) === 65279 ? text.slice(1) : text).split("\n").map((raw, index) => {
+		const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+		const indent = /^ */.exec(line)?.[0].length ?? 0;
+		return {
+			no: index + 1,
+			indent,
+			text: line.slice(indent),
+			raw: line
+		};
+	});
+	let at = 0;
+	const blank = (line) => line.text === "" || line.text.startsWith("#");
+	const skipBlank = () => {
+		while (at < lines.length && blank(lines[at])) at++;
+	};
+	skipBlank();
+	if (at < lines.length && /^---\s*(?:#.*)?$/.test(lines[at].raw)) {
+		at++;
+		skipBlank();
+	}
+	const fail = (message, line) => {
+		throw new YamlError(message, line?.no ?? 0);
+	};
+	/** A plain scalar's text with a trailing ` #comment` removed. */
+	const plain = (value) => {
+		const comment = /(?:^|\s)#/.exec(value);
+		return (comment === null ? value : value.slice(0, comment.index)).trim();
+	};
+	const checkScalarStart = (value, line) => {
+		if (/^[&*!]/.test(value)) fail(`anchors, aliases and tags are not supported (${value.split(/\s/)[0]})`, line);
+		if (/^[[{]/.test(value) && !/^(?:\{\s*\}|\[\s*\])\s*(?:#.*)?$/.test(value)) fail("flow collections are not supported: write the entries as a block", line);
+		if (/^[|>]/.test(value) === false && /^[?%@`]/.test(value)) fail(`a scalar cannot start with ${value[0]}: quote it`, line);
+	};
+	/** A quoted scalar starting at `value` on `line`, possibly continued on later lines; folds line breaks. */
+	const quoted = (value, line) => {
+		const quote = value[0];
+		let source = value.slice(1);
+		let out = "";
+		let current = line;
+		for (;;) {
+			for (let i = 0; i < source.length; i++) {
+				const c = source[i];
+				if (quote === "'" && c === "'") {
+					if (source[i + 1] === "'") {
+						out += "'";
+						i++;
+						continue;
+					}
+					return {
+						text: out,
+						rest: source.slice(i + 1)
+					};
+				}
+				if (quote === "\"" && c === "\"") return {
+					text: out,
+					rest: source.slice(i + 1)
+				};
+				if (quote === "\"" && c === "\\") {
+					const next = source[i + 1];
+					if (next === void 0) {
+						source = "";
+						out += "\0";
+						break;
+					}
+					const simple = {
+						n: "\n",
+						t: "	",
+						r: "\r",
+						"0": "\0",
+						"\"": "\"",
+						"\\": "\\",
+						"/": "/",
+						" ": " ",
+						b: "\b",
+						f: "\f",
+						e: "\x1B",
+						N: "…",
+						_: "\xA0"
+					};
+					if (next in simple) {
+						out += simple[next];
+						i++;
+						continue;
+					}
+					const width = next === "x" ? 2 : next === "u" ? 4 : next === "U" ? 8 : 0;
+					if (width === 0) fail(`unknown escape \\${next}`, current);
+					const hex = source.slice(i + 2, i + 2 + width);
+					if (!new RegExp(`^[0-9a-fA-F]{${width}}$`).test(hex)) fail(`malformed escape \\${next}${hex}`, current);
+					out += String.fromCodePoint(Number.parseInt(hex, 16));
+					i += 1 + width;
+					continue;
+				}
+				out += c;
+			}
+			at++;
+			if (at >= lines.length) fail("unterminated quoted scalar", current);
+			let breaks = 0;
+			while (at < lines.length && lines[at].text === "") {
+				breaks++;
+				at++;
+			}
+			if (at >= lines.length) fail("unterminated quoted scalar", current);
+			current = lines[at];
+			if (out.endsWith("\0")) out = out.slice(0, -1);
+			else {
+				out = out.replace(/[ \t]+$/, "");
+				out += breaks > 0 ? "\n".repeat(breaks) : " ";
+			}
+			source = current.text.replace(/^\s+/, "");
+		}
+	};
+	/** A block scalar whose header (`|`, `>-`, `|2`…) is `header`; the content follows `line`. */
+	const blockScalar = (header, parentIndent, line) => {
+		const m = /^([|>])([+-]?)([1-9]?)([+-]?)\s*(?:#.*)?$/.exec(header);
+		if (m === null) fail(`malformed block scalar header ${header}`, line);
+		const [, style, chompA, digit, chompB] = m;
+		const chomp = chompA || chompB;
+		at++;
+		let indent = digit === "" ? -1 : parentIndent + Number(digit);
+		const content = [];
+		while (at < lines.length) {
+			const current = lines[at];
+			if (current.raw.trim() === "") {
+				content.push("");
+				at++;
+				continue;
+			}
+			if (indent === -1) {
+				if (current.indent <= parentIndent) break;
+				indent = current.indent;
+			}
+			if (current.indent < indent) break;
+			content.push(current.raw.slice(indent));
+			at++;
+		}
+		let trailing = 0;
+		while (content.length > 0 && content[content.length - 1] === "") {
+			content.pop();
+			trailing++;
+		}
+		let value;
+		if (style === "|") value = content.join("\n");
+		else {
+			value = "";
+			for (let i = 0; i < content.length; i++) {
+				const piece = content[i];
+				if (i > 0) {
+					const previous = content[i - 1];
+					if (piece === "") value += "\n";
+					else if (previous !== "") value += /^\s/.test(piece) || /^\s/.test(previous) ? "\n" : " ";
+				}
+				value += piece;
+			}
+		}
+		if (content.length === 0) return "";
+		if (chomp === "-") return value;
+		if (chomp === "+") return value + "\n".repeat(trailing + 1);
+		return value + "\n";
+	};
+	/** A plain scalar starting on `line`, with its continuation lines (more indented than `parentIndent`). */
+	const plainScalar = (first, parentIndent) => {
+		let value = plain(first);
+		if (/(?:^|\s)#/.test(first)) {
+			at++;
+			return value;
+		}
+		at++;
+		let breaks = 0;
+		while (at < lines.length) {
+			const current = lines[at];
+			if (current.text === "") {
+				breaks++;
+				at++;
+				continue;
+			}
+			if (current.indent <= parentIndent || current.text.startsWith("#")) break;
+			if (/^[^"'#][^:#]*:(?:\s|$)/.test(current.text) || current.text.startsWith("- ")) break;
+			value += breaks > 0 ? "\n".repeat(breaks) : " ";
+			breaks = 0;
+			value += plain(current.text);
+			const ends = /(?:^|\s)#/.test(current.text);
+			at++;
+			if (ends) break;
+		}
+		return value;
+	};
+	/** The value after `key:` or `- ` (`rest`), at a node whose own indentation is `indent`. */
+	const valueAfter = (rest, indent, line) => {
+		const value = rest.trim();
+		if (value === "" || value.startsWith("#")) {
+			at++;
+			skipBlank();
+			const next = lines[at];
+			if (next === void 0 || next.indent <= indent) {
+				if (next !== void 0 && next.indent === indent && next.text.startsWith("- ")) return node(indent);
+				return null;
+			}
+			return node(next.indent);
+		}
+		checkScalarStart(value, line);
+		if (value === "{}" || /^\{\s*\}/.test(value)) {
+			at++;
+			return {};
+		}
+		if (/^\[\s*\]/.test(value)) {
+			at++;
+			return [];
+		}
+		if (value.startsWith("|") || value.startsWith(">")) return blockScalar(value, indent, line);
+		if (value.startsWith("\"") || value.startsWith("'")) {
+			const result = quoted(value, line);
+			if (plain(result.rest) !== "") fail(`unexpected text after a quoted scalar: ${result.rest.trim()}`, lines[at]);
+			at++;
+			return result.text;
+		}
+		if (value === "~" || value === "null") {
+			at++;
+			return null;
+		}
+		return plainScalar(value, indent);
+	};
+	/** A mapping key at the start of `text`: its name and what follows the `:`. */
+	const keyOf = (text, line) => {
+		if (text.startsWith("\"") || text.startsWith("'")) {
+			const saved = at;
+			const result = quoted(text, line);
+			if (at !== saved) fail("a key cannot span lines", line);
+			const rest = result.rest.replace(/^\s*/, "");
+			if (!rest.startsWith(":")) return null;
+			return {
+				key: result.text,
+				rest: rest.slice(1)
+			};
+		}
+		if (text.startsWith("? ")) fail("complex keys (? …) are not supported", line);
+		const m = /^([^#][^:]*?)\s*:(?:\s|$)/.exec(text);
+		if (m === null) return null;
+		return {
+			key: m[1],
+			rest: text.slice(m[0].length)
+		};
+	};
+	/** A block node whose lines are indented by exactly `indent`. */
+	const node = (indent) => {
+		skipBlank();
+		const first = lines[at];
+		if (first === void 0) return null;
+		if (first.text.startsWith("- ") || first.text === "-") {
+			const out = [];
+			while (at < lines.length) {
+				skipBlank();
+				const line = lines[at];
+				if (line === void 0 || line.indent < indent) break;
+				if (line.indent > indent) fail("unexpected indentation", line);
+				if (!(line.text.startsWith("- ") || line.text === "-")) break;
+				const rest = line.text.slice(1);
+				const inner = rest.trimStart();
+				if (inner !== "" && !/^["'|>]/.test(inner) && keyOf(inner, line) !== null) {
+					const shift = line.indent + 1 + (rest.length - inner.length);
+					lines[at] = {
+						...line,
+						indent: shift,
+						text: inner
+					};
+					out.push(node(shift));
+					continue;
+				}
+				out.push(valueAfter(rest, indent, line));
+			}
+			return out;
+		}
+		const out = {};
+		while (at < lines.length) {
+			skipBlank();
+			const line = lines[at];
+			if (line === void 0 || line.indent < indent) break;
+			if (line.indent > indent) fail("unexpected indentation", line);
+			if (line.text === "..." || line.text === "---") fail("only one YAML document is supported", line);
+			const entry = keyOf(line.text, line);
+			if (entry === null) fail(`expected "key: value", found ${line.text}`, line);
+			const { key, rest } = entry;
+			if (Object.hasOwn(out, key)) fail(`duplicate key ${key}`, line);
+			out[key] = valueAfter(rest, indent, line);
+		}
+		return out;
+	};
+	try {
+		skipBlank();
+		if (at >= lines.length) return {
+			value: {},
+			problem: null
+		};
+		const value = node(lines[at].indent);
+		skipBlank();
+		if (at < lines.length) fail("unexpected indentation", lines[at]);
+		return {
+			value,
+			problem: null
+		};
+	} catch (error) {
+		if (error instanceof YamlError) return {
+			value: void 0,
+			problem: {
+				message: error.message,
+				line: error.line
+			}
+		};
+		throw error;
+	}
+}
+/** Line numbers of YAML keys (`key:` at any depth), for diagnostics. */
+function yamlKeyLines(text) {
+	const lines = /* @__PURE__ */ new Map();
+	text.split("\n").forEach((line, index) => {
+		const m = /^\s*(?:-\s+)?["']?([^"':#]+?)["']?\s*:(?:\s|$)/.exec(line);
+		if (m !== null && !lines.has(m[1])) lines.set(m[1], index + 1);
+	});
+	return lines;
+}
+const KEYWORD_STYLES = /* @__PURE__ */ new Set([
+	"integer",
+	"percent",
+	"short",
+	"medium",
+	"long",
+	"full"
+]);
+/**
+* A message compiled by `formatjs compile --ast` (an array of typed
+* elements) as vi18n's AST; null when an element is not one FormatJS writes.
+*/
+function formatjsAstToIcu(elements) {
+	if (!Array.isArray(elements)) return null;
+	const out = [];
+	for (const element of elements) {
+		if (typeof element !== "object" || element === null) return null;
+		const value = element.value;
+		switch (element.type) {
+			case 0:
+				if (typeof value !== "string") return null;
+				if (value !== "") out.push({
+					type: "literal",
+					value
+				});
+				break;
+			case 1:
+				out.push({
+					type: "argument",
+					name: value
+				});
+				break;
+			case 2:
+			case 3:
+			case 4: {
+				const style = formatjsStyle(element.style);
+				if (style === void 0) return null;
+				out.push({
+					type: element.type === 2 ? "number" : element.type === 3 ? "date" : "time",
+					name: value,
+					style,
+					options: null
+				});
+				break;
+			}
+			case 5:
+			case 6: {
+				const options = [];
+				const raw = element.options;
+				if (typeof raw !== "object" || raw === null) return null;
+				for (const [key, option] of Object.entries(raw)) {
+					const nested = formatjsAstToIcu(option?.value);
+					if (nested === null) return null;
+					options.push({
+						key,
+						value: nested
+					});
+				}
+				if (element.type === 5) out.push({
+					type: "select",
+					name: value,
+					options
+				});
+				else out.push({
+					type: "plural",
+					pluralType: element.pluralType === "ordinal" ? "ordinal" : "cardinal",
+					name: value,
+					offset: typeof element.offset === "number" ? element.offset : 0,
+					options
+				});
+				break;
+			}
+			case 7:
+				out.push({ type: "pound" });
+				break;
+			case 8: {
+				const children = formatjsAstToIcu(element.children);
+				if (children === null) return null;
+				out.push({
+					type: "tag",
+					name: value,
+					children
+				});
+				break;
+			}
+			default: return null;
+		}
+	}
+	return out;
+}
+function formatjsStyle(style) {
+	if (style === null || style === void 0) return null;
+	if (typeof style === "string") {
+		if (style.startsWith("::")) return {
+			kind: "skeleton",
+			value: style.slice(2).trim()
+		};
+		return KEYWORD_STYLES.has(style) ? {
+			kind: "keyword",
+			value: style
+		} : void 0;
+	}
+	if (typeof style !== "object") return void 0;
+	const skeleton = style;
+	if (typeof skeleton.pattern === "string") return {
+		kind: "skeleton",
+		value: skeleton.pattern
+	};
+	if (Array.isArray(skeleton.tokens)) return {
+		kind: "skeleton",
+		value: skeleton.tokens.map((token) => [token.stem, ...token.options ?? []].join("/")).join(" ")
+	};
+}
+/**
+* The id `babel-plugin-formatjs` / `@formatjs/ts-transformer` give a
+* descriptor without one, with the default `idInterpolationPattern`
+* (`[sha512:contenthash:base64:6]` over `defaultMessage#description`).
+*/
+function formatjsId(defaultMessage, description) {
+	const content = description === null || description === "" ? defaultMessage : `${defaultMessage}#${description}`;
+	return createHash("sha512").update(content).digest("base64").slice(0, 6);
+}
+/** Lingui's `generateMessageId(message, context)` (v4+): sha256 over `message␟context`, base64, 6 characters. */
+function linguiId(message, context) {
+	return createHash("sha256").update(message + "" + (context ?? "")).digest("base64").slice(0, 6);
+}
+/** Appends literal text, merging with a preceding literal. */
+function pushLiteral(nodes, value) {
+	if (value === "") return;
+	const last = nodes[nodes.length - 1];
+	if (last?.type === "literal") last.value += value;
+	else nodes.push({
+		type: "literal",
+		value
+	});
+}
+//#endregion
+//#region src/cli/commands/migrate/react.ts
+/**
+* Rich text for the React codemods (i18next `<Trans>`, react-intl rich
+* values, Lingui `<Trans>`): numbered tags (`<0>…</0>`, which vi18n reads as
+* text since a tag name starts with a letter) are renamed after the element
+* they stand for, in the source and every translation alike, and each
+* element becomes a `rich()` handler that wraps the translated children.
+*/
+function newNaming() {
+	return {
+		byPath: /* @__PURE__ */ new Map(),
+		sourcePaths: /* @__PURE__ */ new Set()
+	};
+}
+function baseName(element, path) {
+	if (element === "html") return path.replace(/^html:/, "");
+	if (element === null || element.type !== "JSXElement") return "c" + path.replace(/\W/g, "_");
+	const name = jsxName(element).split(/[.:]/).pop().replace(/^[A-Z]/, (c) => c.toLowerCase()).replace(/[^A-Za-z0-9_-]/g, "");
+	return /^[A-Za-z]/.test(name) ? name : `c${name}`;
+}
+/** Renames the tags of a message (source first, then translations) through `naming`. */
+function renameTags(nodes, naming, pathOf, elementAt, source) {
+	const taken = new Set(naming.byPath.values());
+	const walk = (list, parent) => list.map((node) => {
+		if (node.type === "plural" || node.type === "select") return {
+			...node,
+			options: node.options.map((o) => ({
+				key: o.key,
+				value: walk(o.value, parent)
+			}))
+		};
+		if (node.type !== "tag") return node;
+		const path = pathOf(node.name, parent);
+		let name = node.name;
+		if (path !== null) {
+			const known = naming.byPath.get(path);
+			if (known !== void 0) name = known;
+			else {
+				const base = baseName(elementAt(path), path);
+				name = base;
+				for (let n = 2; taken.has(name); n++) name = `${base}${n}`;
+				naming.byPath.set(path, name);
+				taken.add(name);
+			}
+			if (source) naming.sourcePaths.add(path);
+		}
+		return {
+			type: "tag",
+			name,
+			children: node.children === null ? null : walk(node.children, path ?? parent)
+		};
+	});
+	return walk(nodes, null);
+}
+/** This site's handler per tag name, or the paths it cannot map. */
+function siteHandlers(naming, elementAt) {
+	const handlers = /* @__PURE__ */ new Map();
+	const missing = [];
+	for (const path of naming.sourcePaths) {
+		const name = naming.byPath.get(path);
+		const element = elementAt(path);
+		if (element === "html") handlers.set(name, {
+			element: null,
+			html: path.replace(/^html:/, "")
+		});
+		else if (element !== null && element.type === "JSXElement") handlers.set(name, {
+			element,
+			html: null
+		});
+		else missing.push(path.replace(/^html:/, ""));
+	}
+	return {
+		handlers,
+		missing
+	};
+}
+/** `ReactNode`, imported as a type in TSX so handlers and `rich<ReactNode>()` type-check. */
+function reactTypes(builder) {
+	return { node: builder.typeImport("react", "ReactNode") };
+}
+/** A handler wrapping the translated children in the element's opening tag. */
+function elementHandler(handler, selfClosing, r, types) {
+	const param = types === null ? "children" : `children: ${types.node}`;
+	if (handler.element === null) {
+		const tag = handler.html;
+		return selfClosing ? `() => <${tag} />` : `(${param}) => <${tag}>{children}</${tag}>`;
+	}
+	const element = handler.element;
+	const opening = element.openingElement;
+	if (selfClosing) return `() => ${r.src(opening.start, opening.end).replace(/\s*>$/, "").replace(/\s*\/$/, "")} />`;
+	return `(${param}) => ${r.src(opening.start, opening.end).replace(/\s*\/>$/, ">")}{children}</${jsxName(element)}>`;
+}
+/** Whether a message's tag is written self-closing (`<br/>`, `<0/>`). */
+function selfClosingTags(nodes, out = /* @__PURE__ */ new Set()) {
+	for (const node of nodes) if (node.type === "tag") {
+		if (node.children === null) out.add(node.name);
+		else selfClosingTags(node.children, out);
+	} else if (node.type === "plural" || node.type === "select") for (const option of node.options) selfClosingTags(option.value, out);
+	return out;
+}
+/**
+* Annotates the first parameter of handlers in a values object
+* (`(chunks) => …` → `(chunks: ReactNode) => …`): react-intl's types gave it
+* a type from context, vi18n's values are `unknown`, so under
+* `noImplicitAny` the handler would no longer type-check.
+*/
+function annotateHandlers(builder, values, typeName) {
+	const props = objectProperties(values);
+	if (props === null) return;
+	const text = builder.text;
+	for (const property of props.order) {
+		if (property.type === "SpreadElement") continue;
+		const fn = unwrap(property.value);
+		if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") continue;
+		const param = fn.params[0];
+		if (param === void 0 || param.type !== "Identifier" || isNode(param.typeAnnotation)) continue;
+		const name = param.name;
+		const parenthesized = text.slice(fn.start, param.start).includes("(");
+		builder.replace({
+			start: param.start,
+			end: param.start + name.length
+		}, parenthesized ? `${name}: ${typeName}` : `(${name}: ${typeName})`);
+	}
+}
+/** `rich<ReactNode>(message, { … })`. */
+function richCall(r, key, entries, types) {
+	const typeArgument = types === null ? "" : `<${types.node}>`;
+	return `${r.fn.rich}${typeArgument}(${r.message(key)}, { ${entries.join(", ")} })`;
+}
+/** `name: value`, or the shorthand when the value is the name. */
+function entry(name, code) {
+	if (code === name) return name;
+	return `${/^[A-Za-z_$][\w$]*$/.test(name) || /^(?:0|[1-9]\d*)$/.test(name) ? name : jsString(name)}: ${code}`;
+}
+//#endregion
+//#region src/cli/commands/migrate/i18next.ts
+/**
+* `vi18n migrate --from i18next` (INTERNALS §2.14): i18next and
+* react-i18next.
+*
+* Catalogs are i18next JSON (v4): nested keys joined by `.`, one file per
+* locale or one per namespace (`<locale>/<ns>.json`), plural suffixes
+* (`_zero`, `_one`, …, `_other`, `_ordinal_*`, v3's `_plural`) folded into
+* one ICU plural, `_<context>` variants into a select on `context`, `{{x}}`
+* into `{x}` (`{{x, number}}`, `datetime`, `currency(EUR)` formatted), and
+* `$t(key)` nesting inlined. Call sites: `t("key", options)` from
+* `useTranslation`, `i18next.t`, a `t` prop; `<Trans>` (components from the
+* `components` prop or the children, as react-i18next maps `<0>…</0>`)
+* becomes `rich()`. `useTranslation` bindings, imports and `<I18nextProvider>`
+* go once nothing else uses them; the rest is reported.
+*/
+const MODULE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+const PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
+const ORDINAL_SUFFIX = /_ordinal_(zero|one|two|few|many|other)$/;
+const CATEGORIES = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+const DEFAULT_NS = "translation";
+/** react-i18next's `transKeepBasicHtmlNodesFor`: rendered as elements when no component maps them. */
+const BASIC_HTML = /* @__PURE__ */ new Set([
+	"br",
+	"strong",
+	"i",
+	"p"
+]);
+/** `t()` options that change what is looked up or returned, with no vi18n counterpart. */
+const UNSUPPORTED_OPTIONS = /* @__PURE__ */ new Set([
+	"lng",
+	"lngs",
+	"fallbackLng",
+	"returnObjects",
+	"returnDetails",
+	"joinArrays",
+	"postProcess",
+	"interpolation",
+	"replace",
+	"skipInterpolation"
+]);
+/** `t()` options that only steer the lookup; the rest are values. */
+const LOOKUP_OPTIONS = /* @__PURE__ */ new Set([
+	"defaultValue",
+	"ns",
+	"keyPrefix",
+	"ordinal"
+]);
+function isOldSource(source) {
+	return /^(?:react-|next-)?i18next(?:\/|$)/.test(source) || source.startsWith("i18next-");
+}
+/** Whether a key has plural or ordinal forms (`key_one`, `key_ordinal_two`, v3 `key_plural`). */
+function hasForms(texts, key) {
+	return CATEGORIES.some((c) => texts.has(`${key}_${c}`) || texts.has(`${key}_ordinal_${c}`)) || texts.has(`${key}_plural`);
+}
+/** The base key of a plural or ordinal form (`item_one` → `item`). */
+function baseKey(key) {
+	return key.replace(ORDINAL_SUFFIX, "").replace(PLURAL_SUFFIX, "").replace(/_plural$/, "");
+}
+/** One `{{…}}` as an ICU node: `count` in a plural branch is `#`. */
+function interpolationNode(inner, inPlural) {
+	const body = inner.trim().replace(/^-\s*/, "");
+	const comma = body.indexOf(",");
+	const name = (comma === -1 ? body : body.slice(0, comma)).trim();
+	const format = comma === -1 ? null : body.slice(comma + 1).trim();
+	if (!/^[A-Za-z_$][\w$]*$/.test(name)) return { error: `{{${inner}}} reads a nested value, which an ICU argument cannot name` };
+	if (format === null) return { node: inPlural && name === "count" ? { type: "pound" } : {
+		type: "argument",
+		name
+	} };
+	const m = /^(\w+)(?:\((.*)\))?$/.exec(format);
+	const kind = m?.[1]?.toLowerCase();
+	const args = m?.[2]?.trim() ?? "";
+	if (kind === "number" && args === "") return { node: {
+		type: "number",
+		name,
+		style: null,
+		options: null
+	} };
+	if (kind === "datetime" && args === "") return { node: {
+		type: "date",
+		name,
+		style: null,
+		options: null
+	} };
+	if (kind === "currency") {
+		const code = /^(?:currency\s*:\s*)?["']?([A-Za-z]{3})["']?$/.exec(args)?.[1];
+		if (code !== void 0) return { node: {
+			type: "number",
+			name,
+			style: {
+				kind: "skeleton",
+				value: `currency/${code.toUpperCase()}`
+			},
+			options: null
+		} };
+	}
+	return { error: `{{${inner.trim()}}} uses the ${format} format, which has no ICU counterpart: format the value with fmt.* and pass the string` };
+}
+function createI18nextAdapter() {
+	/** locale → namespace → key → text. */
+	const catalogs = /* @__PURE__ */ new Map();
+	const namings = /* @__PURE__ */ new Map();
+	/** `ns:key` of every source text a call site names, its plural and context forms and nested `$t()` included. */
+	const referenced = /* @__PURE__ */ new Set();
+	/** Marks a key family (`key`, `key_one`, `key_male_other`…) and what its texts nest as named by code. */
+	const reference = (ns, key, depth = 0) => {
+		if (depth > 8) return;
+		for (const [k, text] of namespaces(sourceLocale).get(ns) ?? []) {
+			if (k !== key && !k.startsWith(key + "_")) continue;
+			if (referenced.has(`${ns}:${k}`)) continue;
+			referenced.add(`${ns}:${k}`);
+			for (const m of text.value.matchAll(/\$t\(([^(),]*)/g)) {
+				const target = m[1].trim();
+				const colon = target.indexOf(":");
+				if (colon !== -1 && namespaces(sourceLocale).has(target.slice(0, colon))) reference(target.slice(0, colon), target.slice(colon + 1), depth + 1);
+				else reference(ns, target, depth + 1);
+			}
+		}
+	};
+	let sourceLocale = "";
+	let defaultNs = null;
+	const namespaces = (locale) => catalogs.get(locale) ?? /* @__PURE__ */ new Map();
+	const textOf = (locale, ns, key) => namespaces(locale).get(ns)?.get(key);
+	/** Whether the source locale has `key` itself or one of its plural forms. */
+	const hasKey = (ns, key) => {
+		const texts = namespaces(sourceLocale).get(ns);
+		if (texts === void 0) return false;
+		return texts.has(key) || hasForms(texts, key);
+	};
+	/** The namespace holding `key`: the call's own, the default, or the only one that has it. */
+	const findNamespace = (key, preferred) => {
+		if (preferred !== null) return hasKey(preferred, key) ? preferred : null;
+		if (defaultNs !== null && hasKey(defaultNs, key)) return defaultNs;
+		const found = [...namespaces(sourceLocale).keys()].filter((ns) => hasKey(ns, key));
+		return found.length === 1 ? found[0] : null;
+	};
+	const messageKey = (ns, key) => ns === defaultNs ? key : `${ns}:${key}`;
+	/** Whether a source key only has plural forms, so a call must pass `count`. */
+	const isPlural = (ns, key) => {
+		const texts = namespaces(sourceLocale).get(ns);
+		return texts !== void 0 && !texts.has(key) && hasForms(texts, key);
+	};
+	/** `{{x}}`, `$t(…)` and, for `<Trans>`, `<0>…</0>` of one text as ICU nodes. */
+	const convert = (raw, locale, ns, tags, inPlural, depth = 0) => {
+		const root = [];
+		const stack = [];
+		const current = () => stack.length === 0 ? root : stack[stack.length - 1].nodes;
+		const token = /\{\{(.*?)\}\}|\$t\(([^()]*)\)|<(\/?)([A-Za-z0-9_-]+)\s*(\/?)>/g;
+		let at = 0;
+		for (let m = token.exec(raw); m !== null; m = token.exec(raw)) {
+			const [whole, interpolation, nested, closing, tag, selfClosing] = m;
+			if (tag !== void 0 && !tags) continue;
+			pushLiteral(current(), raw.slice(at, m.index));
+			at = m.index + whole.length;
+			if (interpolation !== void 0) {
+				const node = interpolationNode(interpolation, inPlural);
+				if ("error" in node) return node;
+				current().push(node.node);
+			} else if (nested !== void 0) {
+				if (depth > 8) return { error: "$t() nests deeper than 8 levels" };
+				if (nested.includes(",")) return { error: `$t(${nested}) passes options, which cannot be inlined` };
+				let target = nested.trim();
+				let targetNs = ns;
+				const colon = target.indexOf(":");
+				if (colon !== -1 && namespaces(locale).has(target.slice(0, colon))) {
+					targetNs = target.slice(0, colon);
+					target = target.slice(colon + 1);
+				}
+				const text = textOf(locale, targetNs, target);
+				if (text === void 0) return { error: `$t(${nested}) names no message in ${locale}` };
+				const inner = convert(text.value, locale, targetNs, tags, inPlural, depth + 1);
+				if ("error" in inner) return inner;
+				for (const node of inner.nodes) if (node.type === "literal") pushLiteral(current(), node.value);
+				else current().push(node);
+			} else if (closing === "/") {
+				const open = stack.pop();
+				if (open === void 0 || open.name !== tag) return { error: `</${tag}> closes no <${tag}>` };
+				current().push({
+					type: "tag",
+					name: open.name,
+					children: open.nodes
+				});
+			} else if (selfClosing === "/") current().push({
+				type: "tag",
+				name: tag,
+				children: null
+			});
+			else stack.push({
+				name: tag,
+				nodes: []
+			});
+		}
+		if (stack.length > 0) return { error: `<${stack[stack.length - 1].name}> is never closed` };
+		pushLiteral(current(), raw.slice(at));
+		return { nodes: root };
+	};
+	/** One key's text, or its plural forms as an ICU plural. */
+	const branch = (locale, ns, key, shape) => {
+		const texts = namespaces(locale).get(ns);
+		if (texts === void 0) return null;
+		if (shape.count) {
+			const categories = pluralCategories(locale)[shape.ordinal ? "ordinal" : "cardinal"];
+			const forms = [];
+			for (const category of CATEGORIES) {
+				const formKey = shape.ordinal ? `${key}_ordinal_${category}` : `${key}_${category}`;
+				const text = texts.get(formKey);
+				if (text === void 0) continue;
+				const converted = convert(text.value, locale, ns, shape.tags, true);
+				if ("error" in converted) return { error: `${formKey}: ${converted.error}` };
+				forms.push({
+					key: category === "zero" && !categories.includes("zero") ? "=0" : category,
+					value: converted.nodes
+				});
+			}
+			const legacy = texts.get(`${key}_plural`);
+			if (forms.length === 0 && legacy !== void 0 && !shape.ordinal) for (const [category, text] of [["one", texts.get(key)], ["other", legacy]]) {
+				if (text === void 0) continue;
+				const converted = convert(text.value, locale, ns, shape.tags, true);
+				if ("error" in converted) return converted;
+				forms.push({
+					key: category,
+					value: converted.nodes
+				});
+			}
+			if (forms.length > 0) {
+				if (!forms.some((f) => f.key === "other")) {
+					const plain = texts.get(key);
+					if (plain === void 0) return { error: `${key} has plural forms but no ${key}_other` };
+					const converted = convert(plain.value, locale, ns, shape.tags, true);
+					if ("error" in converted) return converted;
+					forms.push({
+						key: "other",
+						value: converted.nodes
+					});
+				}
+				const order = ["=0", ...CATEGORIES];
+				forms.sort((a, b) => order.indexOf(a.key) - order.indexOf(b.key));
+				return { nodes: [{
+					type: "plural",
+					pluralType: shape.ordinal ? "ordinal" : "cardinal",
+					name: "count",
+					offset: 0,
+					options: forms
+				}] };
+			}
+		}
+		const text = texts.get(key);
+		return text === void 0 ? null : convert(text.value, locale, ns, shape.tags, false);
+	};
+	/** The message of a key and shape in one locale; null when the locale has none of its keys. */
+	const build = (locale, ns, key, shape) => {
+		if (!shape.context) return branch(locale, ns, key, shape);
+		const contexts = /* @__PURE__ */ new Set();
+		const keys = /* @__PURE__ */ new Set([...namespaces(sourceLocale).get(ns)?.keys() ?? [], ...namespaces(locale).get(ns)?.keys() ?? []]);
+		for (const k of keys) {
+			if (!k.startsWith(key + "_")) continue;
+			const rest = baseKey(k.slice(key.length + 1));
+			if (rest === "" || CATEGORIES.includes(rest) || rest === "plural" || rest.includes(".")) continue;
+			contexts.add(rest);
+		}
+		const options = [];
+		for (const context of [...contexts].sort()) {
+			const converted = branch(locale, ns, `${key}_${context}`, shape);
+			if (converted === null) continue;
+			if ("error" in converted) return converted;
+			options.push({
+				key: context,
+				value: converted.nodes
+			});
+		}
+		const other = branch(locale, ns, key, shape);
+		if (other !== null && "error" in other) return other;
+		if (options.length === 0 && other === null) return null;
+		options.push({
+			key: "other",
+			value: other === null ? [] : other.nodes
+		});
+		return { nodes: [{
+			type: "select",
+			name: "context",
+			options
+		}] };
+	};
+	/** Every text of a key family in a locale, for a translator comment. */
+	const originalTexts = (locale, ns, key) => {
+		const parts = [];
+		for (const [k, text] of namespaces(locale).get(ns) ?? []) if (k === key) parts.push(text.value);
+		else if (k.startsWith(key + "_")) parts.push(`${k.slice(key.length + 1)}: ${text.value}`);
+		return parts.join(" | ");
+	};
+	/**
+	* Registers the message of a key and shape; its registry key, or why it
+	* cannot be. Tags are named through `tags` (path rules and the defining
+	* site's elements); a later site of the same message reuses the naming.
+	*/
+	const define = (env, ns, key, shape, fallback, tags) => {
+		const id = messageKey(ns, key) + (shape.context ? " {context}" : "") + (shape.ordinal ? " {ordinal}" : "") + (shape.tags ? " <Trans>" : "");
+		if (env.message(id) !== void 0) return { key: id };
+		let source = build(sourceLocale, ns, key, shape);
+		if (source === null && fallback !== null) source = convert(fallback, sourceLocale, ns, shape.tags, false);
+		if (source === null) return { problem: `${messageKey(ns, key)} is in no ${sourceLocale} catalog` };
+		if ("error" in source) return { problem: `${messageKey(ns, key)}: ${source.error}` };
+		const naming = newNaming();
+		const finish = (nodes, isSource) => printICU(tags === null ? nodes : renameTags(nodes, naming, tags.pathOf, tags.elementAt, isSource));
+		const sourceText = finish(source.nodes, true);
+		const translations = /* @__PURE__ */ new Map();
+		for (const locale of catalogs.keys()) {
+			if (locale === sourceLocale) continue;
+			const converted = build(locale, ns, key, shape);
+			if (converted === null) continue;
+			const first = [...namespaces(locale).get(ns) ?? []].find(([k]) => k === key || k.startsWith(key + "_"))?.[1];
+			translations.set(locale, "error" in converted ? {
+				unconverted: originalTexts(locale, ns, key),
+				reason: converted.error,
+				...first === void 0 ? {} : {
+					file: first.file,
+					line: first.line
+				}
+			} : { icu: finish(converted.nodes, false) });
+		}
+		let origin = textOf(sourceLocale, ns, key);
+		for (const [k, text] of namespaces(sourceLocale).get(ns) ?? []) {
+			if (origin !== void 0) break;
+			if (k.startsWith(key + "_")) origin = text;
+		}
+		if (!env.define({
+			key: id,
+			named: true,
+			source: sourceText,
+			context: null,
+			hint: null,
+			translations,
+			file: origin?.file ?? "",
+			line: origin?.line ?? 0
+		})) return { problem: `${messageKey(ns, key)} could not be converted` };
+		if (tags !== null) namings.set(id, naming);
+		return { key: id };
+	};
+	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;
+		}
+		const parsed = parseJson(text);
+		if (parsed.problem !== null) {
+			env.report("catalog-parse", parsed.problem.message, {
+				file: file.file,
+				line: parsed.problem.line
+			}, "error");
+			return;
+		}
+		const flat = flattenTree(parsed.value, text);
+		for (const problem of flat.problems) env.report("migrate-unconverted", problem.message, {
+			file: file.file,
+			line: problem.line
+		});
+		const ns = file.namespace ?? DEFAULT_NS;
+		let byNs = catalogs.get(file.locale);
+		if (byNs === void 0) catalogs.set(file.locale, byNs = /* @__PURE__ */ new Map());
+		let texts = byNs.get(ns);
+		if (texts === void 0) byNs.set(ns, texts = /* @__PURE__ */ new Map());
+		for (const [key, value] of flat.texts) texts.set(key, {
+			...value,
+			file: file.file
+		});
+	};
+	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 = /\.[mc]?tsx$/.test(extname(file)) || extname(file) === ".tsx";
+		const imported = (name) => {
+			const locals = /* @__PURE__ */ new Set();
+			for (const declaration of info.imports) {
+				if (!isOldSource(declaration.source)) continue;
+				for (const s of declaration.specifiers) if (s.imported === name) locals.add(s.local);
+			}
+			return locals;
+		};
+		const useTranslation = imported("useTranslation");
+		const transNames = imported("Trans");
+		const providers = imported("I18nextProvider");
+		const instances = /* @__PURE__ */ new Set([
+			...imported("default"),
+			...imported("i18n"),
+			...imported("i18next")
+		]);
+		const importedT = imported("t");
+		const withTranslation = imported("withTranslation");
+		const scopes = /* @__PURE__ */ new Map();
+		const hookInstances = /* @__PURE__ */ new Set();
+		const fixedLocale = /* @__PURE__ */ new Set();
+		for (const binding of info.bindings) {
+			const init = binding.declarator?.init;
+			if (init === null || init === void 0) continue;
+			const call = unwrap(init);
+			if (call.type !== "CallExpression") continue;
+			const callee = identifierName(call.callee);
+			const isHook = callee !== null && useTranslation.has(callee);
+			const fixed = memberParts(call.callee)?.property === "getFixedT";
+			if (!isHook && !fixed) continue;
+			const args = call.arguments;
+			if (isHook) builder.hooks.push(binding);
+			const nsNode = isHook ? args[0] : args[1];
+			let ns = null;
+			if (nsNode !== void 0) {
+				const n = unwrap(nsNode);
+				ns = stringValue(n) ?? (n.type === "ArrayExpression" ? stringValue(n.elements[0]) : null);
+			}
+			const options = isHook ? args[1] : args[2];
+			const prefix = options === void 0 ? null : stringValue(objectProperties(options)?.properties.get("keyPrefix")?.value);
+			const slot = binding.slot;
+			const pattern = binding.declarator.id;
+			const role = slot === null ? "t" : slot.type === "Property" ? keyName(slot) : pattern.type === "ArrayPattern" ? pattern.elements.indexOf(slot) === 0 ? "t" : "i18n" : null;
+			if (role === "i18n") hookInstances.add(binding);
+			else if (role === "t") scopes.set(binding, {
+				ns,
+				prefix
+			});
+			const lng = args[0] === void 0 ? null : unwrap(args[0]);
+			if (fixed && lng !== null && !(lng.type === "Literal" && lng.value === null) && identifierName(lng) !== "undefined") {
+				fixedLocale.add(binding);
+				builder.note(call.start, "getFixedT(lng) pins a locale; its calls were not rewritten: use withLocale(lng, () => t(…)) or createTranslator(lng) from @menapo/vi18n/server");
+			}
+		}
+		/** The innermost binding of `name` visible at `offset`. */
+		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;
+		};
+		/** Keys a computed key can produce, defined so they reach the `msg()` table. */
+		const computedKeys = (node, ns, prefix) => {
+			const all = [];
+			for (const [space, texts] of namespaces(sourceLocale)) {
+				if (ns !== null && space !== ns) continue;
+				for (const key of new Set([...texts.keys()].map(baseKey))) all.push({
+					ns: space,
+					key
+				});
+			}
+			const found = /* @__PURE__ */ new Set();
+			const add = (entryNs, key) => {
+				const shape = {
+					count: isPlural(entryNs, key),
+					ordinal: false,
+					context: false,
+					tags: false
+				};
+				const defined = define(env, entryNs, key, shape, null, null);
+				reference(entryNs, key);
+				if ("key" in defined) found.add(defined.key);
+			};
+			const escape = (q) => q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			const visitKey = (n) => {
+				if (n.type === "Literal" && typeof n.value === "string") {
+					const key = prefix === null ? n.value : `${prefix}.${n.value}`;
+					for (const e of all) if (e.key === key) add(e.ns, e.key);
+				} else if (n.type === "TemplateLiteral") {
+					const quasis = n.quasis.map((q) => q.value.cooked ?? "");
+					if (prefix !== null) quasis[0] = `${prefix}.${quasis[0]}`;
+					if (/[A-Za-z]/.test(quasis.join(""))) {
+						const pattern = new RegExp("^" + quasis.map(escape).join("[^]+?") + "$");
+						for (const e of all) if (pattern.test(e.key)) add(e.ns, e.key);
+					}
+					return;
+				}
+				for (const [, child] of childEntries(n)) visitKey(child);
+			};
+			visitKey(node);
+			return [...found];
+		};
+		/** `t(key, options)` or `<x>.t(key, options)`. */
+		const tCall = (node) => {
+			const callee = unwrap(node.callee);
+			const args = node.arguments;
+			let known = false;
+			let consume = [];
+			let scope = {
+				ns: null,
+				prefix: null
+			};
+			let pinned = false;
+			if (callee.type === "Identifier") {
+				const name = callee.name;
+				const binding = resolve(name, callee.start);
+				if (binding !== null && scopes.has(binding)) {
+					known = true;
+					pinned = fixedLocale.has(binding);
+					scope = scopes.get(binding);
+				} else if (importedT.has(name)) known = true;
+				else if (name !== "t" || binding?.kind === "import") return;
+				consume = [callee];
+			} else {
+				const member = memberParts(callee);
+				if (member === null || member.property !== "t") return;
+				const object = unwrap(member.object);
+				if (object.type === "Identifier") {
+					consume = [object];
+					const binding = resolve(object.name, object.start);
+					if (binding !== null && scopes.has(binding)) {
+						known = true;
+						pinned = fixedLocale.has(binding);
+						scope = scopes.get(binding);
+					} else if (instances.has(object.name) || binding !== null && hookInstances.has(binding)) known = true;
+				}
+			}
+			const first = args[0];
+			if (first === void 0 || first.type === "SpreadElement") return;
+			const options = args[1];
+			const optionProps = options === void 0 ? null : objectProperties(options);
+			let rawKey = stringValue(first);
+			if (rawKey === null) {
+				const keys = computedKeys(first, scope.ns, scope.prefix);
+				if (keys.length > 0 || known) builder.note(first.start, `t(${text.slice(first.start, first.end)}) uses a computed key and was not rewritten`, keys);
+				return;
+			}
+			const label = JSON.stringify(rawKey);
+			let ns = stringValue(optionProps?.properties.get("ns")?.value) ?? scope.ns;
+			const colon = rawKey.indexOf(":");
+			if (colon !== -1 && namespaces(sourceLocale).has(rawKey.slice(0, colon))) {
+				ns = rawKey.slice(0, colon);
+				rawKey = rawKey.slice(colon + 1);
+			}
+			const key = scope.prefix === null ? rawKey : `${scope.prefix}.${rawKey}`;
+			const fallback = options !== void 0 && optionProps === null ? stringValue(options) : stringValue(optionProps?.properties.get("defaultValue")?.value);
+			const resolvedNs = findNamespace(key, ns);
+			if (resolvedNs !== null) reference(resolvedNs, key);
+			if (resolvedNs === null && fallback === null) {
+				if (known) builder.note(node.start, `t(${label}): the key is in no ${sourceLocale} catalog; not rewritten`);
+				return;
+			}
+			const unsupported = [...optionProps?.properties.keys() ?? []].filter((k) => UNSUPPORTED_OPTIONS.has(k));
+			if (unsupported.length > 0 || args.length > 2) {
+				builder.note(node.start, unsupported.includes("lng") || unsupported.includes("lngs") ? `t(${label}) fixes a locale (${unsupported.join(", ")}): use withLocale(lng, () => t(…)) from @menapo/vi18n/server; not rewritten` : `t(${label}, …) passes ${unsupported.join(", ") || "a third argument"}, which vi18n has no counterpart for; not rewritten`);
+				return;
+			}
+			const finalNs = resolvedNs ?? ns ?? defaultNs ?? DEFAULT_NS;
+			if (pinned) {
+				const shape = {
+					count: isPlural(finalNs, key),
+					ordinal: false,
+					context: false,
+					tags: false
+				};
+				const defined = define(env, finalNs, key, shape, fallback, null);
+				if ("key" in defined) builder.note(node.start, `t(${label}) uses a locale getFixedT() pinned; not rewritten`, [defined.key]);
+				return;
+			}
+			const passesValues = options !== void 0 && optionProps === null && fallback === null;
+			const shape = {
+				count: optionProps?.properties.has("count") === true || passesValues && isPlural(finalNs, key),
+				ordinal: optionProps?.properties.has("ordinal") === true,
+				context: optionProps?.properties.has("context") === true,
+				tags: false
+			};
+			if (!shape.count && isPlural(finalNs, key)) {
+				builder.note(node.start, `t(${label}) has plural forms but passes no count; not rewritten`);
+				return;
+			}
+			const defined = define(env, finalNs, key, shape, fallback, null);
+			if ("problem" in defined) {
+				builder.note(node.start, `${defined.problem}; t(${label}) was not rewritten`);
+				return;
+			}
+			const kept = (optionProps?.order ?? []).filter((p) => p.type === "SpreadElement" || !LOOKUP_OPTIONS.has(keyName(p) ?? ""));
+			builder.site(node, (r) => {
+				let values = "";
+				if (kept.length > 0) values = `, { ${kept.map((p) => r.src(p.start, p.end)).join(", ")} }`;
+				else if (passesValues) values = `, ${r.src(options.start, options.end)}`;
+				return `${r.fn.t}(${r.message(defined.key)}${values})`;
+			}, {
+				keys: [defined.key],
+				uses: ["t"],
+				consume
+			});
+		};
+		/** `<Trans>` as `rich()`, or `t()` when its message has no tags. */
+		const trans = (element) => {
+			const attributes = jsxAttributes(element);
+			const attr = (name) => attributes.named.get(name)?.value ?? null;
+			const has = (name) => attributes.named.has(name);
+			if (attributes.spreads.length > 0) {
+				builder.note(element.start, "<Trans {...props}> spreads props and was not rewritten");
+				return;
+			}
+			for (const name of [
+				"tOptions",
+				"parent",
+				"i18nIsDynamicList",
+				"shouldUnescape"
+			]) if (has(name)) {
+				builder.note(element.start, `<Trans ${name}> has no vi18n counterpart; not rewritten`);
+				return;
+			}
+			const children = jsxChildren(element);
+			const childString = nodesToString(children);
+			let rawKey = has("i18nKey") ? attributeString(attr("i18nKey")) : null;
+			if (has("i18nKey") && rawKey === null) {
+				builder.note(element.start, "<Trans i18nKey={…}> with a computed key was not rewritten");
+				return;
+			}
+			const fallback = has("defaults") ? attributeString(attr("defaults")) : childString.ok ? childString.text : null;
+			rawKey ??= fallback;
+			if (rawKey === null || rawKey === "") {
+				builder.note(element.start, `<Trans> without i18nKey: ${childString.reason || "no text"}; not rewritten`);
+				return;
+			}
+			let ns = has("ns") ? attributeString(attr("ns")) : null;
+			const colon = rawKey.indexOf(":");
+			if (colon !== -1 && namespaces(sourceLocale).has(rawKey.slice(0, colon))) {
+				ns = rawKey.slice(0, colon);
+				rawKey = rawKey.slice(colon + 1);
+			}
+			const resolvedNs = findNamespace(rawKey, ns);
+			if (resolvedNs !== null) reference(resolvedNs, rawKey);
+			const finalNs = resolvedNs ?? ns ?? defaultNs ?? DEFAULT_NS;
+			const componentsExpr = has("components") ? attributeExpression(attr("components")) : null;
+			let indexed = children;
+			let named = null;
+			if (componentsExpr !== null) {
+				const c = unwrap(componentsExpr);
+				if (c.type === "ArrayExpression") indexed = c.elements.map((e) => e === null ? c : unwrap(e));
+				else {
+					const props = objectProperties(c);
+					if (props === null || props.spreads.length > 0) {
+						builder.note(element.start, "<Trans components={…}> is not a literal object or array; not rewritten");
+						return;
+					}
+					named = new Map([...props.properties].map(([k, p]) => [k, unwrap(p.value)]));
+					indexed = null;
+				}
+			}
+			const pathOf = (name, parent) => {
+				if (/^\d+$/.test(name) && indexed !== null) return parent === null ? name : `${parent}.${name}`;
+				if (named?.has(name) === true) return name;
+				if (BASIC_HTML.has(name)) return `html:${name}`;
+				return null;
+			};
+			const elementAt = (path) => {
+				if (path.startsWith("html:")) return "html";
+				if (named !== null && !/^\d/.test(path)) return named.get(path) ?? null;
+				let scope = indexed;
+				let found = null;
+				for (const part of path.split(".")) {
+					found = scope?.[Number(part)] ?? null;
+					if (found === null || found.type !== "JSXElement") return null;
+					scope = jsxChildren(found);
+				}
+				return found;
+			};
+			const shape = {
+				count: has("count"),
+				ordinal: false,
+				context: has("context"),
+				tags: true
+			};
+			const defined = define(env, finalNs, rawKey, shape, resolvedNs === null ? fallback : null, {
+				pathOf,
+				elementAt
+			});
+			if ("problem" in defined) {
+				builder.note(element.start, `${defined.problem}; <Trans> 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, `<Trans>: ${missing.map((m) => `<${m}>`).join(", ")} ${missing.length === 1 ? "maps" : "map"} to no element here; not rewritten`, [defined.key]);
+				return;
+			}
+			const selfClosing = selfClosingTags(env.codec.parse(message.canonical));
+			const values = [];
+			const valuesExpr = has("values") ? attributeExpression(attr("values")) : null;
+			if (valuesExpr !== null) {
+				const props = objectProperties(valuesExpr);
+				if (props === null) {
+					builder.note(element.start, "<Trans values={…}> is not an object literal; not rewritten");
+					return;
+				}
+				values.push(...props.order);
+			}
+			const collect = (list) => {
+				for (const child of list) {
+					if (child.type === "JSXElement") collect(jsxChildren(child));
+					if (child.type !== "JSXExpressionContainer") continue;
+					const props = objectProperties(child.expression);
+					if (props !== null) values.push(...props.order.filter((p) => p.type === "SpreadElement" || keyName(p) !== "format"));
+				}
+			};
+			collect(children);
+			const extra = [];
+			for (const name of ["count", "context"]) {
+				const expression = has(name) ? attributeExpression(attr(name)) : null;
+				if (expression !== null) extra.push([name, expression]);
+			}
+			const rich = handlers.size > 0;
+			const types = rich && tsx ? reactTypes(builder) : null;
+			builder.site(element, (r) => {
+				const entries = [];
+				for (const [name, handler] of handlers) entries.push(entry(name, elementHandler(handler, selfClosing.has(name), r, types)));
+				for (const p of values) entries.push(r.src(p.start, p.end));
+				for (const [name, expression] of extra) entries.push(entry(name, r.src(expression.start, expression.end)));
+				const call = rich ? richCall(r, defined.key, entries, types) : `${r.fn.t}(${r.message(defined.key)}${entries.length > 0 ? `, { ${entries.join(", ")} }` : ""})`;
+				return inJsxChildren(info, element) ? `{${call}}` : call;
+			}, {
+				keys: [defined.key],
+				uses: [rich ? "rich" : "t"],
+				consume: jsxNameNodes(element)
+			});
+		};
+		const unwrapProvider = (element) => {
+			const children = jsxChildren(element);
+			const opening = element.openingElement;
+			const closing = element.closingElement;
+			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)}</>`;
+			});
+		};
+		/** Setup and APIs without a mechanical counterpart, reported. */
+		const otherCall = (node) => {
+			const name = identifierName(node.callee);
+			if (name !== null && withTranslation.has(name)) {
+				builder.note(node.start, "withTranslation() injects t as a prop: drop it and import t from @menapo/vi18n where the component calls it");
+				return;
+			}
+			const member = memberParts(node.callee);
+			if (member === null) return;
+			let root = unwrap(member.object);
+			for (;;) if (root.type === "CallExpression") root = unwrap(root.callee);
+			else if (root.type === "MemberExpression") root = unwrap(root.object);
+			else break;
+			const object = identifierName(root);
+			const isInstance = object !== null && (instances.has(object) || /^i18n(?:ext)?$/.test(object));
+			if (member.property === "init" && isInstance) builder.note(node.start, "i18next.init(): delete this setup once nothing uses i18next; vi18n needs only its Vite plugin and vi18n.config.ts");
+			else if (member.property === "changeLanguage" && isInstance) builder.note(node.start, "changeLanguage(lng): use setLocale(lng) from @menapo/vi18n");
+			else if (member.property === "exists" && isInstance) builder.note(node.start, "exists(key) has no vi18n counterpart: every message the code names exists");
+		};
+		const visit = (node) => {
+			if (node.type === "CallExpression") {
+				tCall(node);
+				otherCall(node);
+			} else if (node.type === "JSXElement") {
+				const name = jsxName(node);
+				if (transNames.has(name)) trans(node);
+				else if (providers.has(name)) unwrapProvider(node);
+				else if (imported("Translation").has(name)) builder.note(node.start, "<Translation> render props are not rewritten: call t() from @menapo/vi18n inside");
+			}
+			for (const [, child] of childEntries(node)) visit(child);
+		};
+		visit(program);
+		return builder.finish();
+	};
+	return {
+		catalogExtensions: [".json"],
+		catalogsRequired: true,
+		extensions: MODULE_EXTENSIONS,
+		mentions: (text) => /i18next|\bt\s*\(|<Trans\b/.test(text),
+		load(files, env) {
+			sourceLocale = env.config.sourceLocale;
+			for (const file of files) readCatalog(file, env);
+			const source = namespaces(sourceLocale);
+			defaultNs = source.has(DEFAULT_NS) ? DEFAULT_NS : source.size === 1 ? [...source.keys()][0] : null;
+		},
+		planFile: planModule,
+		unusedKeys() {
+			const out = /* @__PURE__ */ new Set();
+			for (const [ns, texts] of namespaces(sourceLocale)) for (const key of texts.keys()) if (!referenced.has(`${ns}:${key}`)) out.add(messageKey(ns, key));
+			return [...out];
+		}
+	};
+}
+/** react-i18next's `nodesToString`: the key and default text `<Trans>` derives from its children. */
+function nodesToString(children) {
+	let text = "";
+	for (const [index, child] of children.entries()) {
+		if (child.type === "JSXText") {
+			text += cleanJsxText(child.value);
+			continue;
+		}
+		if (child.type === "JSXExpressionContainer") {
+			const expression = unwrap(child.expression);
+			const literal = stringValue(expression);
+			if (literal !== null) {
+				text += literal;
+				continue;
+			}
+			const props = objectProperties(expression);
+			if (props !== null && props.spreads.length === 0) {
+				const format = stringValue(props.properties.get("format")?.value);
+				const names = [...props.properties.keys()].filter((k) => k !== "format");
+				if (names.length === 1) {
+					text += `{{${format === null ? names[0] : `${names[0]}, ${format}`}}}`;
+					continue;
+				}
+			}
+			return {
+				ok: false,
+				text,
+				reason: `{${text.length > 0 ? "…" : ""}} holds an expression, not text or {{ value }}`
+			};
+		}
+		if (child.type === "JSXElement") {
+			const name = jsxName(child);
+			const attributes = child.openingElement.attributes;
+			const inner = jsxChildren(child);
+			const basic = BASIC_HTML.has(name);
+			if (inner.length === 0) {
+				text += basic && attributes.length === 0 ? `<${name}/>` : `<${index}></${index}>`;
+				continue;
+			}
+			if (basic && attributes.length === 0 && inner.length === 1 && inner[0].type === "JSXText") {
+				text += `<${name}>${cleanJsxText(inner[0].value)}</${name}>`;
+				continue;
+			}
+			const nested = nodesToString(inner);
+			if (!nested.ok) return nested;
+			text += `<${index}>${nested.text}</${index}>`;
+			continue;
+		}
+		return {
+			ok: false,
+			text,
+			reason: `a ${child.type} child`
+		};
+	}
+	return {
+		ok: true,
+		text,
+		reason: ""
+	};
+}
+//#endregion
+export { linguiId as _, annotateHandlers as a, pushLiteral as b, newNaming as c, richCall as d, selfClosingTags as f, formatjsId as g, formatjsAstToIcu as h, isOldSource as i, reactTypes as l, flattenTree as m, createI18nextAdapter as n, elementHandler as o, siteHandlers as p, interpolationNode as r, entry as s, MODULE_EXTENSIONS as t, renameTags as u, parseJson as v, yamlKeyLines as x, parseYaml as y };