@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/migrate-dPgq9uzy.js

@@ -0,0 +1,1484 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { o as isValidManualId, r as validateTranslation } from "./validate-BxpupdAf.js";
+import { n as printICU } from "./codec-DuvU2VQy.js";
+import { S as entryKey, m as updateCatalogFile, p as serializeCatalog, s as catalogPath, w as sourceMatches } from "./library-D5CWvTQs.js";
+import { i as listProjectFiles, r as isIncluded } from "./project-pXipT8iG.js";
+import { t as VERSION } from "./version-BlyLGlOa.js";
+import { l as langFromId, u as parseModule } from "./worker-84U6uYB3.js";
+import { t as syncCatalog } from "./sync-CcVzger_.js";
+import { i as rootRelative, r as plural } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, i as hasErrors, n as compareText, o as loadProject, t as CliExit } from "./project-Dwx7iPm6.js";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+//#region src/cli/commands/migrate.ts
+/**
+* `vi18n migrate --from saas-i18n --catalog <file> [--catalog <l>=<file>]…
+* [--write]` (INTERNALS §2.14, PLAN §11): moves a project from `@saas/i18n`'s
+* key catalogue to vi18n manual ids.
+*
+* - `<x>.t("key"[, values])` with a catalogue key becomes
+*   `t({ id: "key", message: "<text>" }[, values])`, importing `t` once; so
+*   does a call of a local bound to `<x>.t` (`const t = i18nFor(l).t`,
+*   `const { t } = i18n`);
+* - computed keys are not rewritten: every catalogue key the expression can
+*   produce becomes a `msg()` descriptor in `messages.vi18n.ts` beside the
+*   catalogue, and the call site is reported (`migrate-dynamic-key`); so
+*   does a key spelled as a string anywhere else (a route table, a helper's
+*   argument), so no key the code names is dropped as unused;
+* - other locales' texts become `translated` manual entries.
+*
+* Catalogues are read with the parser, never executed. Without `--write`
+* nothing is written and the plan is printed; any error writes nothing.
+*/
+const RUNTIME = "@menapo/vi18n";
+const MESSAGES_MODULE = "messages.vi18n.ts";
+/** Extensions parsed as modules; everything else (`.astro`, `.vue`, `.svelte`, `.mdx`) is scanned lexically. */
+const MODULE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+/** `@saas/i18n` placeholders: `{name}`, `{name:date}`, `{name:number}`, `{name:currency}`. */
+const PLACEHOLDER = /\{(\w+)(?::(date|number|currency))?\}/g;
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/** Children in source order (ESTree field order is source order for every node vi18n meets). */
+function* children(node) {
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) yield item;
+		} else if (isNode(value)) yield value;
+	}
+}
+function unwrapExpression(node) {
+	let current = node;
+	for (;;) if (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "TSTypeAssertion" || current.type === "ParenthesizedExpression") current = current.expression;
+	else return current;
+}
+/**
+* The value of a string-like expression: a string literal, a template
+* without substitutions, or a `+` concatenation of those; null otherwise.
+*/
+function staticString(node) {
+	const n = unwrapExpression(node);
+	if (n.type === "Literal" && typeof n.value === "string") return n.value;
+	if (n.type === "TemplateLiteral" && n.expressions.length === 0) return n.quasis[0].value.cooked;
+	if (n.type === "BinaryExpression" && n.operator === "+") {
+		const left = staticString(n.left);
+		const right = staticString(n.right);
+		return left === null || right === null ? null : left + right;
+	}
+	return null;
+}
+function propertyKey(property) {
+	const key = property.key;
+	if (property.computed === true) return staticString(key);
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal") return String(key.value);
+	return null;
+}
+/**
+* The exported object literal of a catalogue module (`export const en = {…}`,
+* with or without a type annotation or `satisfies`, or `export default {…}`),
+* flattened: nested objects join their keys with `.`.
+*/
+function readCatalogue(text, file, locale, display) {
+	const diagnostics = [];
+	const catalogue = {
+		file,
+		locale,
+		texts: /* @__PURE__ */ new Map()
+	};
+	const fail = (message, offset = 0) => {
+		const diagnostic = {
+			code: "catalog-parse",
+			severity: "error",
+			message,
+			file: display
+		};
+		if (offset > 0) Object.assign(diagnostic, positionOf(text, offset));
+		diagnostics.push(diagnostic);
+	};
+	let program;
+	try {
+		program = parseModule(text, langFromId(file), file).program;
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		diagnostics.push({
+			...error.diagnostic,
+			file: display
+		});
+		return {
+			catalogue,
+			diagnostics
+		};
+	}
+	const objects = [];
+	for (const statement of program.body) if (statement.type === "ExportDefaultDeclaration") {
+		const value = unwrapExpression(statement.declaration);
+		if (value.type === "ObjectExpression") objects.push(value);
+	} else if (statement.type === "ExportNamedDeclaration" && isNode(statement.declaration)) {
+		const declaration = statement.declaration;
+		if (declaration.type !== "VariableDeclaration") continue;
+		for (const declarator of declaration.declarations) {
+			if (!isNode(declarator.init)) continue;
+			const value = unwrapExpression(declarator.init);
+			if (value.type === "ObjectExpression") objects.push(value);
+		}
+	}
+	if (objects.length !== 1) {
+		fail(objects.length === 0 ? `${basename(file)} exports no object literal; a saas-i18n catalogue is a module exporting one object of strings` : `${basename(file)} exports ${objects.length} object literals; a saas-i18n catalogue exports exactly one`);
+		return {
+			catalogue,
+			diagnostics
+		};
+	}
+	const walk = (object, prefix) => {
+		for (const property of object.properties) {
+			if (property.type !== "Property") {
+				fail("spread properties cannot be read without executing the catalogue; inline them", property.start);
+				continue;
+			}
+			const key = propertyKey(property);
+			if (key === null) {
+				fail("a computed key cannot be read without executing the catalogue", property.start);
+				continue;
+			}
+			const value = unwrapExpression(property.value);
+			if (value.type === "ObjectExpression") {
+				walk(value, prefix + key + ".");
+				continue;
+			}
+			const textValue = staticString(value);
+			if (textValue === null) {
+				fail(`the value of "${prefix + key}" is not a string literal`, value.start);
+				continue;
+			}
+			catalogue.texts.set(prefix + key, textValue);
+		}
+	};
+	walk(objects[0], "");
+	return {
+		catalogue,
+		diagnostics
+	};
+}
+/**
+* A saas-i18n message as ICU text. Placeholders become arguments
+* (`{n:number}` → `{n, number}`, `{d:date}` → `{d, date, medium}`, the ICU
+* style nearest saas's `dateStyle: "medium"`, the same text in English only);
+* everything else is literal text, quoted by the
+* canonical printer where ICU would read it as syntax (`{`, `<b`, `'{`).
+*/
+function saasToIcu(text) {
+	const nodes = [];
+	const currency = [];
+	const literal = (value) => {
+		if (value === "") return;
+		const last = nodes[nodes.length - 1];
+		if (last?.type === "literal") last.value += value;
+		else nodes.push({
+			type: "literal",
+			value
+		});
+	};
+	let at = 0;
+	for (const match of text.matchAll(PLACEHOLDER)) {
+		literal(text.slice(at, match.index));
+		at = match.index + match[0].length;
+		const name = match[1];
+		const format = match[2];
+		let node;
+		if (format === "number") node = {
+			type: "number",
+			name,
+			style: null,
+			options: null
+		};
+		else if (format === "date") node = {
+			type: "date",
+			name,
+			style: {
+				kind: "keyword",
+				value: "medium"
+			},
+			options: null
+		};
+		else {
+			if (format === "currency") currency.push(name);
+			node = {
+				type: "argument",
+				name
+			};
+		}
+		nodes.push(node);
+	}
+	literal(text.slice(at));
+	return {
+		icu: printICU(nodes),
+		currency
+	};
+}
+/** Names of plain `{name}` placeholders (no `:date`, `:number`, `:currency`) in a saas text, deduplicated. */
+function plainPlaceholders(text) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(PLACEHOLDER)) if (match[2] === void 0) names.add(match[1]);
+	return [...names];
+}
+/**
+* Whether a name usually holds a date: `date`, `updated`, `expires`, or a
+* camel-case or snake-case suffix (`publishedAt`, `startDate`, `created_on`).
+* Number-like names (`days`, `readingTime`) are left out: saas formatted
+* only `Date` values, so they render the same in vi18n.
+*/
+function isDateName(name) {
+	return /^(?:date|datetime|timestamp|when|since|until|deadline|expires|expiry|expiration|created|updated|modified|published|posted|due)$/i.test(name) || /[a-z0-9](?:Date|At|On)$/.test(name) || /^date[A-Z_]/.test(name) || /_(?:date|at|on)$/i.test(name);
+}
+/**
+* The value written for `name` in a call's values object (`{ date: new
+* Date() }`, or `name` itself for `{ date }`); null when the call names no
+* such property. Lexical, so it reads calls in components alike.
+*/
+function valueExpression(call, name) {
+	const property = new RegExp(`[{,]\\s*(?:${name}|"${name}"|'${name}')\\s*:\\s*`).exec(call);
+	if (property === null) return new RegExp(`[{,]\\s*${name}\\s*[,}]`).test(call) ? name : null;
+	const start = property.index + property[0].length;
+	for (let i = start; i < call.length; i++) {
+		const c = call[i];
+		if (c === "," || c === "}" || c === ")") return call.slice(start, i).trim();
+		let end = i + 1;
+		if (c === "(" || c === "[" || c === "{") end = skipBalanced(call, i);
+		else if (c === "\"" || c === "'") end = readString(call, i)?.end ?? null;
+		else if (c === "`") end = readTemplate(call, i)?.end ?? null;
+		if (end === null) return null;
+		i = end - 1;
+	}
+	return null;
+}
+/** Whether a value expression passes a `Date`: `new Date(…)`, or ends in a date-like name (`post.updatedAt`). */
+function looksLikeDate(expression) {
+	const constructed = /^new\s+Date\b\s*/.exec(expression);
+	if (constructed !== null) {
+		const at = constructed[0].length;
+		return at === expression.length || skipBalanced(expression, at) === expression.length;
+	}
+	const last = /([A-Za-z_$][\w$]*)\s*(\(\s*\))?\s*$/.exec(expression.replace(/[!?]+$/, ""));
+	if (last === null) return false;
+	const name = last[1];
+	if (last[2] !== void 0 && DATE_NUMBER_GETTER.test(name)) return false;
+	return isDateName(name);
+}
+/** `Date` methods that return numbers, not dates. */
+const DATE_NUMBER_GETTER = /^(?:get(?:UTC)?(?:Date|Day|FullYear|Month|Hours|Minutes|Seconds|Milliseconds)|getTime|getTimezoneOffset|valueOf)$/;
+/** A key as a valid manual id (INTERNALS §2.2.3): invalid characters → `_`, a key without `.` gets `msg.`. */
+function toManualId(key) {
+	if (isValidManualId(key)) return key;
+	const segments = key.split(".").map((segment) => segment.replace(/[^A-Za-z0-9_:-]/g, "_") || "_");
+	if (segments.length < 2) segments.unshift("msg");
+	return segments.join(".");
+}
+/** Matches catalogue keys against a template's static parts. */
+function templateKeys(quasis, keys) {
+	const found = /* @__PURE__ */ new Set();
+	const literal = quasis.join("");
+	if (!/[A-Za-z]/.test(literal)) return found;
+	const pattern = new RegExp("^" + quasis.map((q) => q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^]+?") + "$");
+	for (const key of keys) if (pattern.test(key)) found.add(key);
+	return found;
+}
+/**
+* Keys searched for as plain strings outside calls: only nested ones
+* (`nav.home`). A one-word key (`quote`) is as likely an ordinary string of
+* the code, and claiming it would only add noise.
+*/
+function isNamedKey(value, keys) {
+	return value.includes(".") && keys.has(value);
+}
+function planModule(file, text, keys, keyList, display) {
+	const plan = {
+		file,
+		text,
+		rewrites: [],
+		dynamic: [],
+		importedT: null,
+		program: null,
+		diagnostics: []
+	};
+	let program;
+	try {
+		program = parseModule(text, langFromId(file), file).program;
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		plan.diagnostics.push({
+			...error.diagnostic,
+			file: display
+		});
+		return plan;
+	}
+	plan.program = program;
+	const runtimeNamespaces = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		if (statement.source.value !== RUNTIME) continue;
+		for (const specifier of statement.specifiers) {
+			const local = specifier.local.name;
+			if (specifier.type === "ImportNamespaceSpecifier") runtimeNamespaces.add(local);
+			else if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported;
+				if ((imported.name ?? imported.value) === "t" && statement.importKind !== "type") plan.importedT = local;
+			}
+		}
+	}
+	const bindings = moduleBindings(program, plan.importedT);
+	const handled = /* @__PURE__ */ new Set();
+	const visit = (node, parent) => {
+		if (node.type === "CallExpression") {
+			const callee = unwrapExpression(node.callee);
+			const args = node.arguments;
+			let receiver = null;
+			if (callee.type === "MemberExpression" && callee.computed !== true && callee.property.type === "Identifier" && callee.property.name === "t") {
+				const object = callee.object;
+				if (!(object.type === "Identifier" && runtimeNamespaces.has(object.name))) receiver = text.slice(object.start, object.end).replace(/\s+/g, "");
+			} else if (callee.type === "Identifier" && bindings.has(callee.name)) receiver = callee.name;
+			const first = args[0];
+			if (receiver !== null && first !== void 0 && first.type !== "SpreadElement") {
+				const key = staticString(first);
+				if (key !== null) {
+					if (keys.has(key)) {
+						const literal = unwrapExpression(first);
+						handled.add(literal.start);
+						const quote = text[literal.start] === "'" ? "'" : "\"";
+						plan.rewrites.push({
+							key,
+							receiver,
+							callee: {
+								start: callee.start,
+								end: callee.end,
+								text: ""
+							},
+							argument: {
+								start: first.start,
+								end: first.end,
+								text: quote
+							},
+							original: text.slice(node.start, node.end),
+							markup: null
+						});
+					}
+				} else plan.dynamic.push({
+					offset: first.start,
+					expression: text.slice(first.start, first.end),
+					keys: expressionKeys(first, keys, keyList, handled),
+					receiver
+				});
+			}
+		}
+		if (node.type === "ObjectExpression") {
+			const properties = node.properties.filter((p) => p.type === "Property");
+			if (properties.some((p) => propertyKey(p) === "message")) {
+				for (const p of properties) if (propertyKey(p) === "id") handled.add(p.value.start);
+			}
+		}
+		if (node.type === "Literal" && typeof node.value === "string" && isNamedKey(node.value, keys) && !handled.has(node.start) && isKeyPosition(node, parent)) plan.dynamic.push({
+			offset: node.start,
+			expression: text.slice(node.start, node.end),
+			keys: /* @__PURE__ */ new Set([node.value]),
+			receiver: null,
+			literal: true
+		});
+		if (node.type === "TemplateLiteral" && !handled.has(node.start)) {
+			if (node.expressions.length > 0) {
+				const found = templateKeys(node.quasis.map((q) => q.value.cooked ?? ""), keyList);
+				if (found.size > 0) plan.dynamic.push({
+					offset: node.start,
+					expression: text.slice(node.start, node.end),
+					keys: found,
+					receiver: null
+				});
+			}
+		}
+		for (const child of children(node)) visit(child, node);
+	};
+	visit(program, null);
+	return plan;
+}
+/**
+* Locals bound to a saas `t` (`const t = i18nFor(l).t`, `const { t } =
+* i18n`), whose calls are call sites like `<x>.t(…)`. Scopes are ignored:
+* a call of an unrelated local of the same name only matters when its
+* first argument is a catalogue key.
+*/
+function moduleBindings(program, importedT) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (node.type === "VariableDeclarator") {
+			const id = node.id;
+			const init = isNode(node.init) ? unwrapExpression(node.init) : null;
+			if (id.type === "Identifier" && init !== null && init.type === "MemberExpression" && init.computed !== true && init.property.name === "t") names.add(id.name);
+			else if (id.type === "ObjectPattern") for (const property of id.properties) {
+				if (property.type !== "Property" || propertyKey(property) !== "t") continue;
+				let value = property.value;
+				if (value.type === "AssignmentPattern") value = value.left;
+				if (value.type === "Identifier") names.add(value.name);
+			}
+		}
+		for (const child of children(node)) visit(child);
+	};
+	visit(program);
+	if (importedT !== null) names.delete(importedT);
+	return names;
+}
+/**
+* Whether a string literal equal to a key is a use of that key: not an
+* object key, a module specifier or a type.
+*/
+function isKeyPosition(node, parent) {
+	if (parent === null) return true;
+	switch (parent.type) {
+		case "ImportDeclaration":
+		case "ExportNamedDeclaration":
+		case "ExportAllDeclaration":
+		case "ImportExpression":
+		case "TSLiteralType":
+		case "TSExternalModuleReference": return false;
+		case "Property": return parent.key !== node || parent.computed === true;
+		default: return true;
+	}
+}
+/** Catalogue keys an expression can evaluate to: its string literals and templates that match keys. */
+function expressionKeys(node, keys, keyList, handled) {
+	const found = /* @__PURE__ */ new Set();
+	const visit = (n) => {
+		if (n.type === "Literal" && typeof n.value === "string" && keys.has(n.value)) {
+			found.add(n.value);
+			handled.add(n.start);
+		}
+		if (n.type === "TemplateLiteral") {
+			handled.add(n.start);
+			const quasis = n.quasis.map((q) => q.value.cooked ?? "");
+			for (const key of templateKeys(quasis, keyList)) found.add(key);
+		}
+		for (const child of children(n)) visit(child);
+	};
+	visit(node);
+	return found;
+}
+/** `.t(` or `?.t(`; the receiver before it is found by walking back. */
+const MEMBER_T = /\??\.\s*t\s*\(/g;
+/** Words after which `(` opens an expression, not a call: `return (a).t(…)`. */
+const KEYWORDS = /* @__PURE__ */ new Set([
+	"return",
+	"typeof",
+	"await",
+	"case",
+	"in",
+	"of",
+	"new",
+	"void",
+	"delete",
+	"yield",
+	"else",
+	"do"
+]);
+const ESCAPES = {
+	n: "\n",
+	t: "	",
+	r: "\r",
+	b: "\b",
+	f: "\f",
+	v: "\v",
+	0: "\0"
+};
+/** A JS string literal starting at `at` (a quote): its value and end, or null when unterminated. */
+function readString(text, at) {
+	const quote = text[at];
+	let value = "";
+	for (let i = at + 1; i < text.length; i++) {
+		const c = text[i];
+		if (c === quote) return {
+			value,
+			end: i + 1
+		};
+		if (c === "\n") return null;
+		if (c === "\\") {
+			const next = text[++i];
+			if (next === void 0) return null;
+			if (next === "u" || next === "x") {
+				const hex = next === "x" ? text.slice(i + 1, i + 3) : text.slice(i + 1, i + 5);
+				value += String.fromCharCode(Number.parseInt(hex, 16));
+				i += hex.length;
+			} else if (next === "\n") {} else value += ESCAPES[next] ?? next;
+			continue;
+		}
+		value += c;
+	}
+	return null;
+}
+/** A template literal starting at `at`: cooked static parts, and its end. */
+function readTemplate(text, at) {
+	const quasis = [""];
+	for (let i = at + 1; i < text.length; i++) {
+		const c = text[i];
+		if (c === "`") return {
+			quasis,
+			end: i + 1
+		};
+		if (c === "\\") {
+			quasis[quasis.length - 1] += text[++i] ?? "";
+			continue;
+		}
+		if (c === "$" && text[i + 1] === "{") {
+			const end = skipBalanced(text, i + 1);
+			if (end === null) return null;
+			i = end - 1;
+			quasis.push("");
+			continue;
+		}
+		quasis[quasis.length - 1] += c;
+	}
+	return null;
+}
+/** From an opening bracket at `at`, the offset after its matching close (strings and templates skipped). */
+function skipBalanced(text, at) {
+	let depth = 0;
+	for (let i = at; i < text.length; i++) {
+		const c = text[i];
+		if (c === "(" || c === "[" || c === "{") depth++;
+		else if (c === ")" || c === "]" || c === "}") {
+			depth--;
+			if (depth === 0) return i + 1;
+		} else if (c === "\"" || c === "'") {
+			const s = readString(text, i);
+			if (s === null) return null;
+			i = s.end - 1;
+		} else if (c === "`") {
+			const s = readTemplate(text, i);
+			if (s === null) return null;
+			i = s.end - 1;
+		}
+	}
+	return null;
+}
+/** The end of a call argument starting at `at`: the next `,` or `)` at depth 0. */
+function argumentEnd(text, at) {
+	for (let i = at; i < text.length; i++) {
+		const c = text[i];
+		if (c === "," || c === ")") return i;
+		if (c === "(" || c === "[" || c === "{") {
+			const end = skipBalanced(text, i);
+			if (end === null) return null;
+			i = end - 1;
+		} else if (c === "\"" || c === "'") {
+			const s = readString(text, i);
+			if (s === null) return null;
+			i = s.end - 1;
+		} else if (c === "`") {
+			const s = readTemplate(text, i);
+			if (s === null) return null;
+			i = s.end - 1;
+		}
+	}
+	return null;
+}
+function skipSpace(text, at) {
+	let i = at;
+	while (i < text.length && /\s/.test(text[i])) i++;
+	return i;
+}
+/** From a closing bracket at `at`, the offset of its opening one (strings skipped), or null. */
+function matchBack(text, at) {
+	let depth = 0;
+	for (let i = at; i >= 0; i--) {
+		const c = text[i];
+		if (c === ")" || c === "]" || c === "}") depth++;
+		else if (c === "(" || c === "[" || c === "{") {
+			depth--;
+			if (depth === 0) return i;
+		} else if (c === "\"" || c === "'" || c === "`") {
+			let j = i - 1;
+			while (j >= 0 && !(text[j] === c && text[j - 1] !== "\\")) j--;
+			if (j < 0) return null;
+			i = j;
+		}
+	}
+	return null;
+}
+/**
+* The start of the receiver ending at `end` (exclusive): identifiers joined
+* by `.`/`?.`, with calls and indexes (`i18nFor(locale).t`, `a[0].t`).
+* Null when there is none (`).t(` after an operator, a number).
+*/
+function receiverStart(text, end) {
+	const back = (j) => {
+		let k = j;
+		while (k > 0 && /\s/.test(text[k - 1])) k--;
+		return k;
+	};
+	let j = back(end);
+	let start = null;
+	for (;;) {
+		const c = text[j - 1];
+		if (c === ")" || c === "]") {
+			const open = matchBack(text, j - 1);
+			if (open === null) return null;
+			j = open;
+			start = j;
+			const before = text[j - 1];
+			if (before !== void 0 && /[\w$)\]]/.test(before)) {
+				let k = j;
+				while (k > 0 && /[\w$]/.test(text[k - 1])) k--;
+				if (KEYWORDS.has(text.slice(k, j))) return start;
+				continue;
+			}
+			if (before === "." && text[j - 2] === "?") {
+				j -= 2;
+				continue;
+			}
+			return start;
+		}
+		if (c !== void 0 && /[\w$]/.test(c)) {
+			let k = j;
+			while (k > 0 && /[\w$]/.test(text[k - 1])) k--;
+			if (/[0-9]/.test(text[k])) return null;
+			start = k;
+			const dot = back(k);
+			if (text[dot - 1] !== ".") return start;
+			j = text[dot - 2] === "?" ? dot - 2 : dot - 1;
+			j = back(j);
+			continue;
+		}
+		return start;
+	}
+}
+/**
+* Locals bound to a saas `t` in a component's script or front matter
+* (`const t = i18nFor(locale).t`, `const { t } = i18n`).
+*/
+function componentBindings(text, importedT) {
+	const names = /* @__PURE__ */ new Set();
+	const declaration = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*/g;
+	for (let match = declaration.exec(text); match !== null; match = declaration.exec(text)) {
+		const at = match.index + match[0].length;
+		let end = at;
+		while (end < text.length && !/[;\n,]/.test(text[end])) {
+			const c = text[end];
+			if (c === "(" || c === "[" || c === "{") {
+				const close = skipBalanced(text, end);
+				if (close === null) break;
+				end = close;
+			} else if (c === "\"" || c === "'") {
+				const literal = readString(text, end);
+				if (literal === null) break;
+				end = literal.end;
+			} else end++;
+		}
+		if (/\??\.\s*t\s*$/.test(text.slice(at, end).trimEnd())) names.add(match[1]);
+	}
+	const destructure = /\b(?:const|let|var)\s*\{([^}]*)\}\s*=/g;
+	for (let match = destructure.exec(text); match !== null; match = destructure.exec(text)) for (const part of match[1].split(",")) {
+		const m = /^\s*t\s*(?::\s*([A-Za-z_$][\w$]*))?\s*(?:=.*)?$/.exec(part);
+		if (m !== null) names.add(m[1] ?? "t");
+	}
+	if (importedT !== null) names.delete(importedT);
+	return names;
+}
+/**
+* A Vue SFC's quoted attribute values, outside `<script>` and `<style>`
+* blocks, and the contents of those blocks (`code`): what lies in neither is
+* template text.
+*/
+function vueRegions(text) {
+	const values = [];
+	const code = [];
+	let i = 0;
+	while (i < text.length) {
+		if (text.startsWith("<!--", i)) {
+			const end = text.indexOf("-->", i + 4);
+			i = end === -1 ? text.length : end + 3;
+			continue;
+		}
+		if (text[i] !== "<" || !/[A-Za-z]/.test(text[i + 1] ?? "")) {
+			i++;
+			continue;
+		}
+		const name = /^<([A-Za-z][\w-]*)/.exec(text.slice(i, i + 64))?.[1]?.toLowerCase() ?? "";
+		i += name.length + 1;
+		while (i < text.length && text[i] !== ">") {
+			const c = text[i];
+			if (c === "\"" || c === "'") {
+				const end = text.indexOf(c, i + 1);
+				if (end === -1) return {
+					attributes: values,
+					code
+				};
+				if (/=\s*$/.test(text.slice(Math.max(0, i - 16), i))) values.push({
+					start: i + 1,
+					end,
+					quote: c
+				});
+				i = end + 1;
+			} else i++;
+		}
+		i++;
+		if (name === "script" || name === "style") {
+			const close = text.indexOf(`</${name}`, i);
+			const end = close === -1 ? text.length : close;
+			code.push({
+				start: i,
+				end
+			});
+			i = end;
+		}
+	}
+	return {
+		attributes: values,
+		code
+	};
+}
+function planComponent(file, text, keys, keyList) {
+	const plan = {
+		file,
+		text,
+		rewrites: [],
+		dynamic: [],
+		importedT: null,
+		program: null,
+		diagnostics: []
+	};
+	const existing = new RegExp(String.raw`import\s*\{([^}]*)\}\s*from\s*["']${RUNTIME.replace("/", "\\/")}["']`).exec(text);
+	if (existing !== null) for (const specifier of existing[1].split(",")) {
+		const m = /^\s*t(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(specifier);
+		if (m !== null) plan.importedT = m[1] ?? "t";
+	}
+	const regions = extname(file) === ".vue" ? vueRegions(text) : null;
+	const markupAt = (offset) => {
+		if (regions === null) return null;
+		if (regions.code.some((r) => r.start <= offset && offset < r.end)) return null;
+		return { quote: regions.attributes.find((a) => a.start <= offset && offset < a.end)?.quote ?? null };
+	};
+	const templatesSeen = /* @__PURE__ */ new Set();
+	/** Ranges already accounted for: rewritten arguments and computed expressions. */
+	const covered = [];
+	const call = (calleeStart, calleeEnd, open, receiver) => {
+		const at = skipSpace(text, open);
+		const c = text[at];
+		if (c === ")") return;
+		const rewrite = (key, end, quote) => {
+			const close = skipBalanced(text, open - 1) ?? end + 1;
+			covered.push([at, end]);
+			plan.rewrites.push({
+				key,
+				receiver,
+				callee: {
+					start: calleeStart,
+					end: calleeEnd,
+					text: ""
+				},
+				argument: {
+					start: at,
+					end,
+					text: quote
+				},
+				original: text.slice(calleeStart, close),
+				markup: markupAt(at)
+			});
+		};
+		if (c === "\"" || c === "'") {
+			const literal = readString(text, at);
+			if (literal === null) return;
+			const after = skipSpace(text, literal.end);
+			if (text[after] !== "," && text[after] !== ")") {
+				const end = argumentEnd(text, at);
+				if (end !== null) pushDynamic(plan, text, at, end, receiver, keys, keyList, templatesSeen, covered);
+				return;
+			}
+			if (keys.has(literal.value)) rewrite(literal.value, literal.end, c);
+			return;
+		}
+		const end = argumentEnd(text, at);
+		if (end === null) return;
+		if (c === "`") {
+			const template = readTemplate(text, at);
+			if (template !== null && template.quasis.length === 1 && skipSpace(text, template.end) === end) {
+				const key = template.quasis[0];
+				templatesSeen.add(at);
+				if (keys.has(key)) rewrite(key, template.end, "\"");
+				return;
+			}
+		}
+		pushDynamic(plan, text, at, end, receiver, keys, keyList, templatesSeen, covered);
+	};
+	MEMBER_T.lastIndex = 0;
+	for (let match = MEMBER_T.exec(text); match !== null; match = MEMBER_T.exec(text)) {
+		const start = receiverStart(text, match.index);
+		if (start === null) continue;
+		const receiver = text.slice(start, match.index).replace(/\s+/g, "");
+		const open = match.index + match[0].length;
+		call(start, text.lastIndexOf("t", open - 1) + 1, open, receiver);
+	}
+	for (const name of componentBindings(text, plan.importedT)) {
+		const pattern = new RegExp(String.raw`(?<![\w$.])${name.replace(/\$/g, "\\$")}\s*\(`, "g");
+		for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+			if (/\bfunction\s*$/.test(text.slice(Math.max(0, match.index - 12), match.index))) continue;
+			call(match.index, match.index + name.length, match.index + match[0].length, name);
+		}
+	}
+	for (let at = text.indexOf("`"); at !== -1; at = text.indexOf("`", at + 1)) {
+		if (templatesSeen.has(at)) continue;
+		const template = readTemplate(text, at);
+		if (template === null) continue;
+		if (template.quasis.length > 1) {
+			const found = templateKeys(template.quasis, keyList);
+			if (found.size > 0) plan.dynamic.push({
+				offset: at,
+				expression: text.slice(at, template.end),
+				keys: found,
+				receiver: null
+			});
+		}
+		at = template.end - 1;
+	}
+	const inCovered = (offset) => covered.some(([a, b]) => a <= offset && offset < b);
+	for (const key of keyList) {
+		if (!isNamedKey(key, keys)) continue;
+		for (const quote of [
+			"\"",
+			"'",
+			"`"
+		]) {
+			const needle = quote + key + quote;
+			for (let at = text.indexOf(needle); at !== -1; at = text.indexOf(needle, at + 1)) {
+				if (inCovered(at)) continue;
+				if (/\bid\s*:\s*$/.test(text.slice(Math.max(0, at - 16), at))) continue;
+				plan.dynamic.push({
+					offset: at,
+					expression: needle,
+					keys: /* @__PURE__ */ new Set([key]),
+					receiver: null,
+					literal: true
+				});
+			}
+		}
+	}
+	plan.dynamic.sort((a, b) => a.offset - b.offset);
+	plan.rewrites.sort((a, b) => a.callee.start - b.callee.start);
+	return plan;
+}
+function pushDynamic(plan, text, start, end, receiver, keys, keyList, templatesSeen, covered) {
+	covered.push([start, end]);
+	const expression = text.slice(start, end).trim();
+	const found = /* @__PURE__ */ new Set();
+	for (let i = start; i < end; i++) {
+		const c = text[i];
+		if (c === "\"" || c === "'") {
+			const s = readString(text, i);
+			if (s === null) break;
+			if (keys.has(s.value)) found.add(s.value);
+			i = s.end - 1;
+		} else if (c === "`") {
+			const s = readTemplate(text, i);
+			if (s === null) break;
+			templatesSeen.add(i);
+			for (const key of templateKeys(s.quasis, keyList)) found.add(key);
+			i = s.end - 1;
+		}
+	}
+	plan.dynamic.push({
+		offset: start,
+		expression,
+		keys: found,
+		receiver
+	});
+}
+/** A JS string literal in the given quote style (a Vue attribute may need single quotes). */
+function quoteJs(value, quote) {
+	if (quote === "\"") return JSON.stringify(value);
+	return "'" + JSON.stringify(value).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'") + "'";
+}
+/**
+* `{ id, message }` in the quote style of the key it replaces, encoded for
+* where it lands. A Vue template decodes entities in attribute values and in
+* `{{ }}` before compiling the expression, so catalogue text there is written
+* as markup: `&` as `&amp;` (else `&#39;` in a message would end its string
+* literal and run the rest as code), an attribute value's own quote as an
+* entity, and in text the `}` of a `}}` as `&#125;`, since `}}` would end the
+* interpolation inside the message (an ICU plural ends with one).
+*/
+function descriptor(info, quote, markup = null) {
+	return encodeMarkup(`{ id: ${quoteJs(info.id, quote)}, message: ${quoteJs(info.canonical, quote)} }`, markup);
+}
+/** Code for where it lands in a Vue template (see {@link descriptor}); unchanged in code. */
+function encodeMarkup(code, markup) {
+	if (markup === null) return code;
+	const html = code.replaceAll("&", "&amp;");
+	if (markup.quote === null) return html.replaceAll("}}", "}&#125;");
+	return html.replaceAll(markup.quote, markup.quote === "\"" ? "&quot;" : "&#39;");
+}
+/** A local name for `t` the file does not already use. */
+function localName(text) {
+	for (const name of [
+		"t",
+		"vt",
+		"vi18nT"
+	]) if (!new RegExp(String.raw`(?<![.\w$])${name}(?![\w$])`).test(text)) return name;
+	return "vi18nT_";
+}
+function importLine(local) {
+	return local === "t" ? `import { t } from "${RUNTIME}";` : `import { t as ${local} } from "${RUNTIME}";`;
+}
+/** Where the import goes, per file kind, creating the script block or front matter a component lacks. */
+function importEdit(file, text, local, program) {
+	return importLineEdit(file, text, importLine(local), program);
+}
+/** {@link importEdit} for any import line (several names, a type import). */
+function importLineEdit(file, text, line, program) {
+	const ext = extname(file);
+	if (program !== null) {
+		let end = -1;
+		for (const statement of program.body) if (statement.type === "ImportDeclaration") end = statement.end;
+		if (end !== -1) return {
+			start: end,
+			end,
+			text: "\n" + line
+		};
+		let at = 0;
+		if (text.startsWith("#!")) at = text.indexOf("\n") + 1;
+		for (const statement of program.body) if (statement.type === "ExpressionStatement" && typeof statement.directive === "string") at = text.indexOf("\n", statement.end) + 1 || statement.end;
+		else break;
+		return {
+			start: at,
+			end: at,
+			text: line + "\n"
+		};
+	}
+	if (ext === ".astro") {
+		const fence = /^\s*---[ \t]*\r?\n/.exec(text);
+		if (fence !== null) return {
+			start: fence[0].length,
+			end: fence[0].length,
+			text: line + "\n"
+		};
+		return {
+			start: 0,
+			end: 0,
+			text: `---\n${line}\n---\n`
+		};
+	}
+	if (ext === ".vue" || ext === ".svelte") {
+		const usable = [...text.matchAll(/<script\b([^>]*)>/g)].filter((m) => {
+			const attrs = m[1];
+			if (/\bsrc\s*=/.test(attrs)) return false;
+			if (ext === ".svelte") return !/\bcontext\s*=\s*["']module["']|\bmodule\b/.test(attrs);
+			return true;
+		});
+		const tag = ext === ".vue" ? usable.find((m) => /\bsetup\b/.test(m[1])) : usable[0];
+		if (tag !== void 0) {
+			const at = tag.index + tag[0].length;
+			return {
+				start: at,
+				end: at,
+				text: "\n" + line
+			};
+		}
+		const options = ext === ".vue" ? usable[0] : void 0;
+		if (options !== void 0) {
+			const lang = /\blang\s*=\s*["']([^"']+)["']/.exec(options[1])?.[1];
+			const close = text.indexOf("<\/script>", options.index);
+			if (close !== -1) {
+				const at = close + 9;
+				return {
+					start: at,
+					end: at,
+					text: `\n${lang === void 0 ? "<script setup>" : `<script setup lang="${lang}">`}\n${line}\n<\/script>`
+				};
+			}
+		}
+		return {
+			start: 0,
+			end: 0,
+			text: `${ext === ".vue" ? "<script setup>" : "<script>"}\n${line}\n<\/script>\n\n`
+		};
+	}
+	const front = /^---\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n/.exec(text);
+	const at = front === null ? 0 : front[0].length;
+	return {
+		start: at,
+		end: at,
+		text: line + "\n\n"
+	};
+}
+function applyEdits(text, edits) {
+	const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+	let out = text;
+	for (const edit of sorted) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+	return out;
+}
+function positionOf(text, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let i = text.indexOf("\n"); i !== -1 && i < offset; i = text.indexOf("\n", i + 1)) {
+		line++;
+		lineStart = i + 1;
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}
+async function migrate(ctx, flags) {
+	if (flags.from !== "saas-i18n") {
+		const { migrateLibrary } = await import("./engine-B7p40M__.js");
+		return migrateLibrary(ctx, flags);
+	}
+	const project = await loadProject(ctx);
+	const { config, codec } = project;
+	const rel = (file) => rootRelative(config.root, file);
+	const data = {
+		from: flags.from,
+		write: flags.write,
+		files: [],
+		rewritten: 0,
+		renamed: [],
+		manualIds: [],
+		messagesModule: null,
+		entries: {},
+		edits: [],
+		unused: []
+	};
+	const diagnostics = [];
+	const [first, ...others] = flags.catalogs;
+	if (first.locale !== null && first.locale !== config.sourceLocale) throw usage(`the first --catalog is the source locale's (${config.sourceLocale}), not ${first.locale}`);
+	for (const other of others) if (other.locale === config.sourceLocale || !config.locales.includes(other.locale)) throw usage(`--catalog ${other.locale}=${other.file}: ${other.locale} must be a configured locale other than the source (${config.locales.join(", ")})`);
+	const catalogues = [];
+	for (const entry of flags.catalogs) {
+		const file = resolve(ctx.global.cwd, entry.file);
+		let text;
+		try {
+			text = await readFile(file, "utf8");
+		} catch (error) {
+			throw usage(`--catalog ${entry.file}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const read = readCatalogue(text, file, entry.locale ?? config.sourceLocale, rel(file));
+		diagnostics.push(...read.diagnostics);
+		catalogues.push(read.catalogue);
+	}
+	const source = catalogues[0];
+	const keys = /* @__PURE__ */ new Map();
+	const takenIds = /* @__PURE__ */ new Map();
+	for (const key of source.texts.keys()) if (isValidManualId(key)) takenIds.set(key, key);
+	for (const [key, text] of source.texts) {
+		const converted = saasToIcu(text);
+		for (const name of converted.currency) diagnostics.push({
+			code: "icu-unknown-currency",
+			severity: "warning",
+			message: `${key}: {${name}:currency} became {${name}}; format the amount with fmt.currencyMinor and pass the string`,
+			file: rel(source.file),
+			id: key
+		});
+		let canonical;
+		try {
+			canonical = codec.canonicalize(converted.icu);
+		} catch (error) {
+			if (!isDiagnosticError(error)) throw error;
+			diagnostics.push({
+				...error.diagnostic,
+				file: rel(source.file),
+				id: key
+			});
+			continue;
+		}
+		let id = toManualId(key);
+		if (id !== key) {
+			if (takenIds.has(id)) {
+				let n = 2;
+				while (takenIds.has(`${id}_${n}`)) n++;
+				id = `${id}_${n}`;
+			}
+			takenIds.set(id, key);
+		}
+		if (id !== key) data.renamed.push({
+			from: key,
+			to: id
+		});
+		keys.set(key, {
+			key,
+			id,
+			canonical
+		});
+	}
+	const keyList = [...keys.keys()];
+	const messagesPath = join(dirname(source.file), MESSAGES_MODULE);
+	const skip = /* @__PURE__ */ new Set([messagesPath, ...catalogues.map((c) => c.file)]);
+	const listed = await listProjectFiles(config);
+	const plans = [];
+	for (const file of listed.files.slice().sort(compareText)) {
+		if (skip.has(file)) continue;
+		const text = await readFile(file, "utf8");
+		if (!/\.\s*t\b|\{[^}]*\bt\b[^}]*\}\s*=/.test(text) && !text.includes("`") && !keyList.some((key) => key.includes(".") && text.includes(key))) continue;
+		const plan = MODULE_EXTENSIONS.has(extname(file)) ? planModule(file, text, keys, keyList, rel(file)) : planComponent(file, text, keys, keyList);
+		diagnostics.push(...plan.diagnostics);
+		if (plan.rewrites.length > 0 || plan.dynamic.length > 0) plans.push(plan);
+	}
+	const receivers = /* @__PURE__ */ new Set();
+	for (const plan of plans) for (const r of plan.rewrites) receivers.add(r.receiver);
+	const dynamicKeys = /* @__PURE__ */ new Set();
+	const used = /* @__PURE__ */ new Map();
+	const use = (key, file) => {
+		let files = used.get(key);
+		if (files === void 0) used.set(key, files = /* @__PURE__ */ new Set());
+		files.add(rel(file));
+	};
+	for (const plan of plans) {
+		for (const r of plan.rewrites) use(r.key, plan.file);
+		for (const site of plan.dynamic) {
+			if (site.keys.size === 0 && (site.receiver === null || !receivers.has(site.receiver))) continue;
+			for (const key of site.keys) {
+				dynamicKeys.add(key);
+				use(key, messagesPath);
+			}
+			const where = positionOf(plan.text, site.offset);
+			const listedKeys = [...site.keys].sort(compareText);
+			const example = listedKeys.length > 0 ? listedKeys.slice(0, 3).join(", ") + (listedKeys.length > 3 ? ", …" : "") : "";
+			diagnostics.push({
+				code: "migrate-dynamic-key",
+				severity: "warning",
+				message: site.literal ? `${site.expression} names a catalogue key outside a call vi18n migrate rewrites; it is a msg() descriptor in ${rel(messagesPath)}: import { messages } from it and call t(messages[key])` : site.keys.size > 0 ? `${site.expression} is a computed key and was not rewritten; its ${plural(site.keys.size, "key")} (${example}) are msg() descriptors in ${rel(messagesPath)}: import { messages } from it and call t(messages[key])` : `${site.receiver}.t(${site.expression}) uses a computed key that matches no catalogue key and was not rewritten; pass a msg() descriptor (t(messages[key])) instead`,
+				file: rel(plan.file),
+				line: where.line,
+				column: where.column
+			});
+		}
+	}
+	for (const key of keyList) if (!used.has(key)) data.unused.push(key);
+	diagnostics.push(...datePlaceholders(source, keys, used, plans, rel));
+	const outputs = [];
+	for (const plan of plans) {
+		if (plan.rewrites.length === 0) continue;
+		const local = plan.importedT ?? localName(plan.text);
+		const edits = [];
+		for (const r of plan.rewrites) {
+			const info = keys.get(r.key);
+			edits.push({
+				...r.callee,
+				text: local
+			});
+			const replacement = descriptor(info, r.argument.text, r.markup);
+			edits.push({
+				...r.argument,
+				text: replacement
+			});
+			const where = positionOf(plan.text, r.callee.start);
+			const to = applyEdits(r.original, [{
+				start: 0,
+				end: r.callee.end - r.callee.start,
+				text: local
+			}, {
+				start: r.argument.start - r.callee.start,
+				end: r.argument.end - r.callee.start,
+				text: replacement
+			}]);
+			data.edits.push({
+				file: rel(plan.file),
+				line: where.line,
+				column: where.column,
+				from: r.original,
+				to
+			});
+		}
+		if (plan.importedT === null) edits.push(importEdit(plan.file, plan.text, local, plan.program));
+		data.rewritten += plan.rewrites.length;
+		outputs.push({
+			file: plan.file,
+			text: applyEdits(plan.text, edits)
+		});
+	}
+	if (dynamicKeys.size > 0) {
+		outputs.push({
+			file: messagesPath,
+			text: messagesModule(dynamicKeys, keys)
+		});
+		data.messagesModule = rel(messagesPath);
+		if (!isIncluded(messagesPath, config)) diagnostics.push({
+			code: "extract-outside-include",
+			severity: "warning",
+			message: `${rel(messagesPath)} is outside project.include, so vi18n extract will not see its msg() descriptors; add its directory to project.include`,
+			file: rel(messagesPath)
+		});
+	}
+	const messages = /* @__PURE__ */ new Map();
+	for (const [key, files] of used) {
+		const info = keys.get(key);
+		messages.set(info.id, {
+			id: info.id,
+			manual: true,
+			canonical: info.canonical,
+			sourceHash: codec.sourceHash(info.canonical),
+			label: codec.label(info.canonical),
+			contexts: [],
+			refs: [...files].sort(compareText),
+			sources: [info.canonical],
+			locations: []
+		});
+	}
+	const translations = /* @__PURE__ */ new Map();
+	for (const catalogue of others.length > 0 ? catalogues.slice(1) : []) {
+		const map = /* @__PURE__ */ new Map();
+		for (const [key, text] of catalogue.texts) {
+			const info = keys.get(key);
+			if (info === void 0 || !used.has(key)) continue;
+			const converted = saasToIcu(text).icu;
+			map.set(info.id, converted);
+			diagnostics.push(...translationProblems(project, catalogue, info, converted, rel(catalogue.file)));
+		}
+		translations.set(catalogue.locale, map);
+	}
+	const loaded = await loadCatalogs(project);
+	const readErrors = loaded.diagnostics.filter((d) => d.code === "catalog-parse" && d.severity === "error");
+	diagnostics.push(...readErrors);
+	const catalogPlans = planCatalogs(project, loaded.set, messages, translations);
+	diagnostics.push(...catalogPlans.diagnostics);
+	for (const [locale, count] of catalogPlans.counts) if (locale !== config.sourceLocale) data.entries[locale] = count;
+	ctx.out.report(diagnostics);
+	const failed = hasErrors(diagnostics);
+	data.files = [...outputs.map((o) => rel(o.file)), ...catalogPlans.changed.map((locale) => rel(catalogPath(config, locale)))];
+	if (flags.write && !failed) {
+		for (const output of outputs) await atomicWrite(output.file, output.text);
+		for (const locale of catalogPlans.changed) {
+			const loadedCatalog = loaded.set.get(locale);
+			await updateCatalogFile(catalogPath(config, locale), loadedCatalog?.hash ?? null, (current) => plannedCatalog(project, locale, current, catalogPlans.sourceCatalog, messages, translations.get(locale)).catalog, {
+				locale,
+				layout: project.layout,
+				isSourceLocale: locale === config.sourceLocale,
+				version: VERSION
+			});
+		}
+	}
+	printPlan(ctx, data, failed);
+	return {
+		exitCode: failed ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+/**
+* T defect C: saas formatted a `Date` in any placeholder with `dateStyle:
+* "medium"`;
+* `migrate` keeps a plain `{x}` as it is, where a `Date` still renders that
+* way but a date string never formats, and the catalogue does not say a date
+* is expected. The value's type is not visible here, so a placeholder is
+* reported when a call passes it something that looks like a `Date`, or when
+* its name says it holds one.
+*/
+function datePlaceholders(source, keys, used, plans, rel) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const plan of plans) for (const r of plan.rewrites) for (const name of plainPlaceholders(source.texts.get(r.key) ?? "")) {
+		const at = `${r.key}\0${name}`;
+		if (seen.has(at)) continue;
+		const value = valueExpression(r.original.slice(r.argument.end - r.callee.start), name);
+		if (value === null || !looksLikeDate(value)) continue;
+		const { line } = positionOf(plan.text, r.callee.start);
+		seen.set(at, {
+			expression: value,
+			file: rel(plan.file),
+			line
+		});
+	}
+	const out = [];
+	for (const [key, text] of source.texts) {
+		if (!keys.has(key) || !used.has(key)) continue;
+		for (const name of plainPlaceholders(text)) {
+			const passed = seen.get(`${key}\0${name}`);
+			if (passed === void 0 && !isDateName(name)) continue;
+			const why = passed === void 0 ? "its name says it holds a date" : `${passed.file}:${passed.line} passes ${passed.expression}`;
+			out.push({
+				code: "migrate-date-placeholder",
+				severity: "warning",
+				message: `${key}: {${name}} may receive a Date (${why}); saas formatted it with dateStyle "medium": write {${name}, date, medium} (the same text in English, not in every locale) and pass a Date or epoch milliseconds (new Date(value) for a string), or pass fmt.date(value, { dateStyle: "medium" }) for saas's exact text`,
+				file: rel(source.file),
+				id: key
+			});
+		}
+	}
+	return out;
+}
+function usage(message) {
+	return new CliExit(EXIT.usage, [{
+		code: "config-invalid",
+		severity: "error",
+		message
+	}]);
+}
+/** A translation that does not fit its source is still written (people fix it), but reported now. */
+function translationProblems(project, catalogue, info, translation, file) {
+	const { codec } = project;
+	try {
+		return validateTranslation(codec.parse(translation), codec.parse(info.canonical), {
+			locale: catalogue.locale,
+			text: translation
+		}).filter((d) => d.severity === "error").map((d) => ({
+			...d,
+			code: "catalog-invalid-translation",
+			severity: "warning",
+			message: `${info.key} (${catalogue.locale}): ${d.message}`,
+			file,
+			locale: catalogue.locale,
+			id: info.id
+		}));
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		return [{
+			...error.diagnostic,
+			severity: "warning",
+			message: `${info.key} (${catalogue.locale}): ${error.diagnostic.message}`,
+			file,
+			locale: catalogue.locale,
+			id: info.id
+		}];
+	}
+}
+/**
+* A locale's catalog after migration: the migrated messages added the way
+* the dev writer adds them (`add-only`, so nothing else changes), then the
+* catalogue's texts set on entries that have no translation yet — a
+* translation someone already made in vi18n is never replaced. `notes` are
+* translator comments for entries left empty (a text the codemod could not
+* convert, kept for a person to finish).
+*/
+function plannedCatalog(project, locale, current, sourceCatalog, messages, translations, notes) {
+	const { config, codec, layout } = project;
+	const synced = syncCatalog({
+		config,
+		codec,
+		messages,
+		locale,
+		catalog: current,
+		sourceCatalog,
+		options: {
+			mode: "add-only",
+			yes: false
+		}
+	});
+	let translated = 0;
+	let catalog = synced.catalog;
+	if (translations !== void 0 && translations.size > 0 || notes !== void 0 && notes.size > 0) {
+		let changed = false;
+		const entries = catalog.entries.map((entry) => {
+			const key = entryKey(entry, layout, codec);
+			if (key === null) return entry;
+			const message = messages.get(key);
+			if (message === void 0 || entry.manualId !== (message.manual ? key : null)) return entry;
+			if (entry.translation !== "" || !sourceMatches(entry, layout, message, codec)) return entry;
+			const text = translations?.get(key);
+			if (text !== void 0) {
+				translated++;
+				changed = true;
+				return {
+					...entry,
+					translation: text,
+					state: "translated",
+					fuzzy: false
+				};
+			}
+			const added = (notes?.get(key) ?? []).filter((note) => !entry.comments.includes(note));
+			if (added.length === 0) return entry;
+			changed = true;
+			return {
+				...entry,
+				comments: [...entry.comments, ...added]
+			};
+		});
+		if (changed) catalog = {
+			...catalog,
+			entries
+		};
+	}
+	return {
+		catalog,
+		added: synced.stats.added,
+		translated,
+		diagnostics: synced.diagnostics
+	};
+}
+function planCatalogs(project, set, messages, translations, notes) {
+	const { config } = project;
+	const sourceCatalog = set.get(config.sourceLocale)?.catalog ?? null;
+	const changed = [];
+	const counts = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	if (messages.size === 0) return {
+		changed,
+		counts,
+		sourceCatalog,
+		diagnostics
+	};
+	for (const locale of config.locales) {
+		const current = set.get(locale)?.catalog ?? null;
+		const planned = plannedCatalog(project, locale, current, sourceCatalog, messages, translations.get(locale), notes?.get(locale));
+		for (const d of planned.diagnostics) diagnostics.push({
+			...d,
+			locale: d.locale ?? locale,
+			file: d.file ?? rootRelative(config.root, catalogPath(config, locale))
+		});
+		counts.set(locale, planned.translated);
+		if ((current === null ? null : serializeCatalog(current, {
+			isSourceLocale: locale === config.sourceLocale,
+			version: VERSION
+		})) !== serializeCatalog(planned.catalog, {
+			isSourceLocale: locale === config.sourceLocale,
+			version: VERSION
+		})) changed.push(locale);
+	}
+	return {
+		changed,
+		counts,
+		sourceCatalog,
+		diagnostics
+	};
+}
+/** `export const messages = { "<key>": msg({ id, message }) }`, keyed by the catalogue key the code computes. */
+function messagesModule(dynamicKeys, keys) {
+	const lines = [
+		"// Generated by vi18n migrate --from saas-i18n: catalogue keys the code computes at",
+		"// runtime, as msg() descriptors so vi18n extracts them. Look one up with",
+		"// t(messages[key]); keys stay the catalogue's, ids are vi18n manual ids.",
+		`import { msg } from "${RUNTIME}";`,
+		"",
+		"export const messages = {"
+	];
+	for (const key of [...dynamicKeys].sort(compareText)) {
+		const info = keys.get(key);
+		lines.push(`  ${JSON.stringify(key)}: msg(${descriptor(info, "\"")}),`);
+	}
+	lines.push("} as const;", "");
+	return lines.join("\n");
+}
+function printPlan(ctx, data, failed) {
+	for (const edit of data.edits) ctx.out.result(`${edit.file}:${edit.line}:${edit.column}\n  - ${edit.from}\n  + ${edit.to}`);
+	if (data.renamed.length > 0) ctx.out.result(`renamed to valid manual ids: ${data.renamed.map((r) => `${r.from} → ${r.to}`).join(", ")}`);
+	if (data.messagesModule !== null) ctx.out.result(`msg() table for computed keys: ${data.messagesModule}`);
+	for (const [locale, count] of Object.entries(data.entries)) ctx.out.result(`${locale}: ${plural(count, "translation")} for the vi18n catalog`);
+	if (data.unused.length > 0) ctx.out.result(`${plural(data.unused.length, "catalogue key")} no code uses: ${data.unused.join(", ")}`);
+	const verb = data.write && !failed ? "rewrote" : "would rewrite";
+	ctx.out.result(`${verb} ${plural(data.rewritten, "call")} in ${plural(data.files.length, "file")}` + (data.write ? failed ? " (nothing written: fix the errors first)" : "" : "; run with --write to apply"));
+}
+async function atomicWrite(path, content) {
+	const temp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await writeFile(temp, content);
+		await rename(temp, path);
+	} catch (error) {
+		await rm(temp, { force: true });
+		throw error;
+	}
+}
+//#endregion
+export { toManualId as _, encodeMarkup as a, migrate as c, positionOf as d, readString as f, skipSpace as g, skipBalanced as h, atomicWrite as i, planCatalogs as l, saasToIcu as m, applyEdits as n, importLineEdit as o, readTemplate as p, argumentEnd as r, isDateName as s, MESSAGES_MODULE as t, plannedCatalog as u, usage as v, vueRegions as y };