@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/rewrite-CiTRAICl.js

@@ -0,0 +1,803 @@
+import { s as decodeEntities } from "./worker-84U6uYB3.js";
+import { o as importLineEdit } from "./migrate-dPgq9uzy.js";
+//#region src/cli/commands/migrate/js.ts
+/**
+* ESTree analysis for the library codemods (`vi18n migrate --from i18next |
+* react-intl | lingui | vue-i18n`, INTERNALS §2.14): a walker that knows
+* each node's parent and field, the module's imports, every binding with the
+* range it is visible in, and every reference by name. That is enough to
+* tell whether the rewrites consumed every use of a hook result or an import
+* (so it can go), and whether a name is free at a call site (so the vi18n
+* import can take it). Scopes are approximated by source ranges: a wrong
+* answer can only keep a binding or alias an import, never capture a name.
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/** Children with the field holding them, in source order. */
+function* childEntries(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 [key, item];
+		} else if (isNode(value)) yield [key, value];
+	}
+}
+function unwrap(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "TSTypeAssertion" || current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+/** A string literal, a template without substitutions, or a `+` of those; null otherwise. */
+function stringValue(node) {
+	if (node === void 0 || node === null) return null;
+	const n = unwrap(node);
+	if (n.type === "Literal" && typeof n.value === "string") return n.value;
+	if (n.type === "TemplateLiteral" && n.expressions.length === 0) {
+		const quasi = n.quasis[0];
+		return quasi === void 0 ? null : quasi.value.cooked;
+	}
+	if (n.type === "BinaryExpression" && n.operator === "+") {
+		const left = stringValue(n.left);
+		const right = stringValue(n.right);
+		return left === null || right === null ? null : left + right;
+	}
+	return null;
+}
+function keyName(property) {
+	const key = property.key;
+	if (property.computed === true) return stringValue(key);
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal") return String(key.value);
+	return null;
+}
+/** `name` of an Identifier (after unwrapping), else null. */
+function identifierName(node) {
+	if (node === void 0 || node === null) return null;
+	const n = unwrap(node);
+	return n.type === "Identifier" ? n.name : null;
+}
+/** `object.property` of a non-computed member call's callee, else null. */
+function memberParts(node) {
+	const n = unwrap(node);
+	if (n.type !== "MemberExpression" || n.computed === true) return null;
+	const property = n.property;
+	if (property.type !== "Identifier" && property.type !== "PrivateIdentifier") return null;
+	return {
+		object: n.object,
+		property: property.name
+	};
+}
+/** The plain properties of an object literal by key; null when a key is computed or a spread is present. */
+function objectProperties(node) {
+	const n = unwrap(node);
+	if (n.type !== "ObjectExpression") return null;
+	const properties = /* @__PURE__ */ new Map();
+	const spreads = [];
+	const order = [];
+	for (const property of n.properties) {
+		order.push(property);
+		if (property.type === "SpreadElement") {
+			spreads.push(property);
+			continue;
+		}
+		const key = keyName(property);
+		if (key === null) return null;
+		properties.set(key, property);
+	}
+	return {
+		properties,
+		spreads,
+		order
+	};
+}
+const FUNCTIONS = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/** Nodes whose range is a block scope for `let`, `const`, `class` and block functions. */
+const BLOCKS = /* @__PURE__ */ new Set([
+	"BlockStatement",
+	"StaticBlock",
+	"ForStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"SwitchStatement",
+	"CatchClause",
+	"ClassBody"
+]);
+/** TypeScript signatures whose parameters bind nothing at runtime. */
+const SIGNATURES = /* @__PURE__ */ new Set([
+	"TSFunctionType",
+	"TSConstructorType",
+	"TSMethodSignature",
+	"TSCallSignatureDeclaration",
+	"TSConstructSignatureDeclaration",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression"
+]);
+function isReferencePosition(node, parent, field) {
+	if (parent === null) return true;
+	switch (parent.type) {
+		case "MemberExpression": return field !== "property" || parent.computed === true;
+		case "Property":
+		case "MethodDefinition":
+		case "PropertyDefinition":
+		case "AccessorProperty":
+		case "TSAbstractMethodDefinition":
+		case "TSAbstractPropertyDefinition":
+		case "TSPropertySignature":
+		case "TSMethodSignature": return field !== "key" || parent.computed === true;
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier":
+		case "ImportAttribute":
+		case "LabeledStatement":
+		case "BreakStatement":
+		case "ContinueStatement":
+		case "MetaProperty":
+		case "TSEnumMember":
+		case "TSTypeParameter":
+		case "TSImportType": return false;
+		case "TSQualifiedName": return field === "left";
+		case "ExportSpecifier": return field === "local" && node === parent.local;
+		default: return true;
+	}
+}
+/** Component names: `<Trans>`, `<Foo.Bar>`'s `Foo`; lowercase names are elements, not bindings. */
+function isJsxReference(node, parent, field) {
+	if (parent === null) return false;
+	const name = node.name;
+	if (parent.type === "JSXMemberExpression") return field === "object";
+	if (parent.type === "JSXOpeningElement" || parent.type === "JSXClosingElement") return field === "name" && !/^[a-z]/.test(name) && !name.includes("-");
+	return false;
+}
+function analyzeModule(program) {
+	const imports = [];
+	const bindings = [];
+	const bindingIds = /* @__PURE__ */ new Set();
+	const references = /* @__PURE__ */ new Map();
+	const parents = /* @__PURE__ */ new Map();
+	const blocks = [program];
+	const functions = [program];
+	const range = (n) => ({
+		start: n.start,
+		end: n.end
+	});
+	const declare = (pattern, scope, kind, declarator, slot = null) => {
+		if (!isNode(pattern)) return;
+		switch (pattern.type) {
+			case "Identifier":
+				bindingIds.add(pattern);
+				bindings.push({
+					name: pattern.name,
+					id: pattern,
+					scope: range(scope),
+					kind,
+					declarator,
+					slot
+				});
+				return;
+			case "ObjectPattern":
+				for (const property of pattern.properties) if (property.type === "RestElement") declare(property, scope, kind, declarator, property);
+				else declare(property.value, scope, kind, declarator, property);
+				return;
+			case "ArrayPattern":
+				for (const element of pattern.elements) if (element !== null) declare(element, scope, kind, declarator, element);
+				return;
+			case "AssignmentPattern":
+				declare(pattern.left, scope, kind, declarator, slot);
+				return;
+			case "RestElement":
+				declare(pattern.argument, scope, kind, declarator, slot);
+				return;
+			case "TSParameterProperty":
+				declare(pattern.parameter, scope, kind, declarator, slot);
+				return;
+		}
+	};
+	const visit = (node, parent, field) => {
+		if (parent !== null && field !== null) parents.set(node, {
+			node: parent,
+			field
+		});
+		const block = blocks[blocks.length - 1];
+		const fn = functions[functions.length - 1];
+		switch (node.type) {
+			case "ImportDeclaration": {
+				const info = {
+					node,
+					source: node.source.value,
+					typeOnly: node.importKind === "type",
+					specifiers: []
+				};
+				for (const specifier of node.specifiers ?? []) {
+					const local = specifier.local;
+					const imported = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.type === "ImportNamespaceSpecifier" ? "*" : specifier.imported.name ?? specifier.imported.value;
+					info.specifiers.push({
+						local: local.name,
+						imported,
+						node: specifier,
+						typeOnly: info.typeOnly || specifier.importKind === "type"
+					});
+					declare(local, program, "import", null, specifier);
+				}
+				imports.push(info);
+				break;
+			}
+			case "VariableDeclaration":
+				for (const declarator of node.declarations) declare(declarator.id, node.kind === "var" ? fn : block, node.kind === "var" ? "var" : "lexical", declarator);
+				break;
+			case "FunctionDeclaration":
+				if (isNode(node.id)) declare(node.id, block, "function", null);
+				break;
+			case "ClassDeclaration":
+				if (isNode(node.id)) declare(node.id, block, "class", null);
+				break;
+			case "ClassExpression":
+			case "FunctionExpression":
+				if (isNode(node.id)) declare(node.id, node, node.type === "ClassExpression" ? "class" : "function", null);
+				break;
+			case "CatchClause":
+				declare(node.param, node, "catch", null);
+				break;
+			case "TSInterfaceDeclaration":
+			case "TSTypeAliasDeclaration":
+			case "TSEnumDeclaration":
+			case "TSModuleDeclaration": if (isNode(node.id)) declare(node.id, block, "type", null);
+		}
+		if (FUNCTIONS.has(node.type)) for (const param of node.params) declare(param, node, "param", null);
+		else if (SIGNATURES.has(node.type)) for (const param of node.params ?? []) declare(param, node, "type", null);
+		if (node.type === "Identifier" && !bindingIds.has(node)) {
+			if (isReferencePosition(node, parent, field)) addReference(references, node);
+		} else if (node.type === "JSXIdentifier" && isJsxReference(node, parent, field)) addReference(references, node);
+		const isFunction = FUNCTIONS.has(node.type);
+		const isBlock = BLOCKS.has(node.type) || isFunction;
+		if (isFunction) functions.push(node);
+		if (isBlock) blocks.push(node);
+		for (const [key, child] of childEntries(node)) visit(child, node, key);
+		if (isBlock) blocks.pop();
+		if (isFunction) functions.pop();
+	};
+	visit(program, null, null);
+	return {
+		program,
+		imports,
+		bindings,
+		references,
+		parentOf: (node) => parents.get(node) ?? null
+	};
+}
+function addReference(references, node) {
+	const name = node.name;
+	let list = references.get(name);
+	if (list === void 0) references.set(name, list = []);
+	list.push(node);
+}
+/**
+* Whether every reference to `binding` (a reference to its name inside its
+* scope) is one the rewrites consumed: it can then be removed.
+*/
+function isConsumed(info, binding, consumed, extra = []) {
+	const inScope = (offset) => binding.scope.start <= offset && offset < binding.scope.end;
+	for (const ref of info.references.get(binding.name) ?? []) if (inScope(ref.start) && !consumed.has(ref.start)) return false;
+	return extra.every((offset) => !inScope(offset) || consumed.has(offset));
+}
+/**
+* Whether an import of `name` at module level would resolve at every offset
+* in `sites` and capture nothing else: no binding left in place declares it
+* at module level or around a site, and no reference the rewrites keep reads
+* a global of that name.
+*/
+function isNameFree(info, name, sites, removed, consumed) {
+	const kept = info.bindings.filter((b) => b.name === name && !removed.has(b.id));
+	for (const b of kept) {
+		if (b.scope.start === info.program.start && b.scope.end === info.program.end) return false;
+		if (sites.some((offset) => b.scope.start <= offset && offset < b.scope.end)) return false;
+	}
+	for (const ref of info.references.get(name) ?? []) {
+		if (consumed.has(ref.start)) continue;
+		if (!kept.some((b) => b.scope.start <= ref.start && ref.start < b.scope.end)) return false;
+	}
+	return true;
+}
+/** The name of a JSX element as written (`Trans`, `Foo.Bar`, `div`). */
+function jsxName(element) {
+	const name = element.openingElement.name;
+	const print = (n) => n.type === "JSXMemberExpression" ? `${print(n.object)}.${n.property.name}` : n.type === "JSXNamespacedName" ? `${n.namespace.name}:${n.name.name}` : n.name;
+	return print(name);
+}
+/** JSXIdentifier nodes naming an element (opening and closing), for consumption. */
+function jsxNameNodes(element) {
+	const out = [];
+	const root = (n) => n.type === "JSXMemberExpression" ? root(n.object) : n;
+	out.push(root(element.openingElement.name));
+	const closing = element.closingElement;
+	if (isNode(closing)) out.push(root(closing.name));
+	return out;
+}
+function jsxAttributes(element) {
+	const named = /* @__PURE__ */ new Map();
+	const spreads = [];
+	for (const attribute of element.openingElement.attributes) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			spreads.push(attribute);
+			continue;
+		}
+		const name = attribute.name;
+		const key = name.type === "JSXNamespacedName" ? `${name.namespace.name}:${name.name.name}` : name.name;
+		named.set(key, {
+			attribute,
+			value: isNode(attribute.value) ? attribute.value : null
+		});
+	}
+	return {
+		named,
+		spreads
+	};
+}
+/** An attribute's expression: the literal itself, or what `{…}` holds; null for `{}` and flags. */
+function attributeExpression(value) {
+	if (value === null) return null;
+	if (value.type === "JSXExpressionContainer") {
+		const expression = value.expression;
+		return expression.type === "JSXEmptyExpression" ? null : expression;
+	}
+	return value;
+}
+/**
+* A static attribute string (`id="x"`, `id={"x"}`, ``id={`x`}``), else null.
+* Oxc keeps entities as written; JSX decodes them in a quoted attribute (not
+* in a string inside `{…}`), as the old library's Babel or TypeScript build did.
+*/
+function attributeString(value) {
+	const expression = attributeExpression(value);
+	if (expression === null) return null;
+	const text = stringValue(expression);
+	return text !== null && value?.type === "Literal" ? decodeEntities(text) : text;
+}
+/**
+* JSX text as React's transform reads it: lines trimmed, lines that are
+* only whitespace dropped, the rest joined by one space; entities decoded
+* first (Oxc's `value` keeps them as written; Babel's had them decoded).
+*/
+function cleanJsxText(value) {
+	const lines = decodeEntities(value).split(/\r\n|\n|\r/);
+	let last = 0;
+	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.test(lines[i])) last = i;
+	let out = "";
+	for (let i = 0; i < lines.length; i++) {
+		let line = lines[i].replace(/\t/g, " ");
+		if (i !== 0) line = line.replace(/^ +/, "");
+		if (i !== lines.length - 1) line = line.replace(/ +$/, "");
+		if (line === "") continue;
+		out += i === last ? line : line + " ";
+	}
+	return out;
+}
+/**
+* A JSX element's children as React passes them: text cleaned (and dropped
+* when empty), empty expression containers (comments) dropped.
+*/
+function jsxChildren(element) {
+	const out = [];
+	for (const child of element.children) if (child.type === "JSXText") {
+		if (cleanJsxText(child.value) !== "") out.push(child);
+	} else if (child.type === "JSXExpressionContainer" && child.expression.type === "JSXEmptyExpression") continue;
+	else out.push(child);
+	return out;
+}
+/** Whether a node sits where JSX expects children (so a replacement needs `{…}`). */
+function inJsxChildren(info, node) {
+	const parent = info.parentOf(node);
+	return parent !== null && parent.field === "children" && (parent.node.type === "JSXElement" || parent.node.type === "JSXFragment");
+}
+/** A statement's range widened to whole lines when it stands alone on them, so no blank line is left. */
+function lineRange(text, start, end) {
+	let s = start;
+	while (s > 0 && (text[s - 1] === " " || text[s - 1] === "	")) s--;
+	let e = end;
+	while (e < text.length && (text[e] === " " || text[e] === "	")) e++;
+	if (!((s === 0 || text[s - 1] === "\n") && (e === text.length || text[e] === "\n" || text[e] === "\r"))) return {
+		start,
+		end
+	};
+	if (text[e] === "\r") e++;
+	if (text[e] === "\n") e++;
+	return {
+		start: s,
+		end: e
+	};
+}
+/**
+* The range that removes one element of a comma-separated list (`items`,
+* in order) together with its separator: the comma after it, or before it
+* when it is the last.
+*/
+function listItemRange(items, index) {
+	const item = items[index];
+	const next = items[index + 1];
+	if (next !== void 0) return {
+		start: item.start,
+		end: next.start
+	};
+	const previous = items[index - 1];
+	if (previous !== void 0) return {
+		start: previous.end,
+		end: item.end
+	};
+	return {
+		start: item.start,
+		end: item.end
+	};
+}
+/** Escapes text for a JS string literal in `quote`. */
+function jsString(value, quote = "\"") {
+	if (quote === "\"") return JSON.stringify(value);
+	return "'" + JSON.stringify(value).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'") + "'";
+}
+//#endregion
+//#region src/cli/commands/migrate/rewrite.ts
+/**
+* Planned file edits for the library codemods (INTERNALS §2.14). An edit
+* replaces a range with text rendered only once every message has its id, so
+* a call site prints `t("Text")` or `t({ id, message })` as the id
+* assignment decides; edits nest (a `<Trans>` inside another one's values),
+* and an outer edit reads its inner ranges through `src()` with the inner
+* edits applied. `ModuleBuilder` adds what every module rewrite needs:
+* removing the old library's hook bindings and imports once the rewrites
+* consumed every use, and choosing local names for the vi18n imports.
+*/
+const RUNTIME_MODULE = "@menapo/vi18n";
+function contains(outer, inner) {
+	if (inner.start < outer.start || inner.end > outer.end) return false;
+	if (inner.start === inner.end) return inner.start > outer.start && inner.start < outer.end;
+	return true;
+}
+function sortEdits(edits) {
+	return [...edits].sort((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		const aEmpty = a.start === a.end;
+		if (aEmpty !== (b.start === b.end)) return aEmpty ? -1 : 1;
+		return b.end - a.end;
+	});
+}
+/**
+* The file with every edit applied, and the top-level edits as the plan
+* lists them (`from` as written, `to` as rendered).
+*/
+function renderPlan(plan, describe) {
+	const text = plan.text;
+	const listed = [];
+	const used = /* @__PURE__ */ new Set();
+	let rewritten = 0;
+	const renderRange = (edits, start, end, top) => {
+		let out = "";
+		let pos = start;
+		for (let i = 0; i < edits.length;) {
+			const edit = edits[i];
+			const nested = [];
+			let j = i + 1;
+			while (j < edits.length && contains(edit, edits[j])) nested.push(edits[j++]);
+			if (edit.start < pos) throw new Error(`vi18n migrate: overlapping edits at ${edit.start} in ${plan.file}`);
+			const rendered = renderEdit(edit, nested);
+			out += text.slice(pos, edit.start) + rendered;
+			if (top && edit.listed !== false) listed.push({
+				start: edit.start,
+				from: text.slice(edit.start, edit.end),
+				to: rendered
+			});
+			pos = edit.end;
+			i = j;
+		}
+		return out + text.slice(pos, end);
+	};
+	const renderEdit = (edit, nested) => {
+		if (edit.keys !== void 0) {
+			rewritten++;
+			for (const key of edit.keys) used.add(key);
+		}
+		if (typeof edit.text === "string") return edit.text;
+		const markup = edit.markup ?? null;
+		const renderer = {
+			src: (start, end) => renderRange(nested.filter((e) => e.start >= start && e.end <= end), start, end, false),
+			message: (key) => describe(key, markup === null || markup.quote !== "\"" ? "\"" : "'", markup),
+			fn: plan.locals,
+			types: plan.types
+		};
+		return edit.text(renderer);
+	};
+	return {
+		text: renderRange(sortEdits(plan.edits), 0, text.length, true),
+		listed,
+		used,
+		rewritten
+	};
+}
+const ALIASES = {
+	t: [
+		"t",
+		"vt",
+		"vi18nT"
+	],
+	msg: [
+		"msg",
+		"vmsg",
+		"vi18nMsg"
+	],
+	rich: [
+		"rich",
+		"vrich",
+		"vi18nRich"
+	]
+};
+var ModuleBuilder = class {
+	edits = [];
+	consumed = /* @__PURE__ */ new Set();
+	used = /* @__PURE__ */ new Set();
+	manual = [];
+	/** Offsets where a vi18n function is called. */
+	sites = [];
+	fns = /* @__PURE__ */ new Set();
+	/** `source` → type names to import (`react` → `ReactNode`). */
+	typeImports = /* @__PURE__ */ new Map();
+	/** Bindings of the old library's hooks (`const { t } = useTranslation()`), removed once consumed. */
+	hooks = [];
+	/** Call sites rewritten. */
+	rewritten = 0;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	get text() {
+		return this.options.text;
+	}
+	get info() {
+		return this.options.info;
+	}
+	/** Marks reference nodes (identifiers, component names) as gone after the rewrite. */
+	consume(nodes) {
+		for (const node of nodes) this.consumed.add(node.start);
+	}
+	/** Every reference inside a range, e.g. a removed element's attributes. */
+	consumeRange(range) {
+		for (const refs of this.info.references.values()) for (const ref of refs) if (ref.start >= range.start && ref.end <= range.end) this.consumed.add(ref.start);
+	}
+	/** A rewritten call site. */
+	site(range, render, options) {
+		for (const key of options.keys) this.used.add(key);
+		for (const fn of options.uses) this.fns.add(fn);
+		this.consume(options.consume ?? []);
+		this.sites.push(range.start);
+		this.rewritten++;
+		this.edits.push({
+			start: range.start,
+			end: range.end,
+			text: render,
+			markup: options.markup ?? null,
+			keys: [...options.keys]
+		});
+	}
+	/** A mechanical replacement that is not a message (an unwrapped provider). */
+	replace(range, text, consume = []) {
+		this.consume(consume);
+		this.edits.push({
+			start: range.start,
+			end: range.end,
+			text
+		});
+	}
+	note(offset, message, keys = []) {
+		this.manual.push({
+			offset,
+			message,
+			keys: [...keys]
+		});
+	}
+	typeImport(source, name) {
+		for (const declaration of this.info.imports) {
+			if (declaration.source !== source) continue;
+			for (const specifier of declaration.specifiers) if (specifier.imported === name) return specifier.local;
+		}
+		let names = this.typeImports.get(source);
+		if (names === void 0) this.typeImports.set(source, names = /* @__PURE__ */ new Set());
+		names.add(name);
+		return name;
+	}
+	finish() {
+		const { info, text } = this.options;
+		const removed = /* @__PURE__ */ new Set();
+		const byDeclarator = /* @__PURE__ */ new Map();
+		for (const binding of this.hooks) {
+			if (!isConsumed(info, binding, this.consumed, this.outsideOf(binding.name))) continue;
+			removed.add(binding.id);
+			const declarator = binding.declarator;
+			let list = byDeclarator.get(declarator);
+			if (list === void 0) byDeclarator.set(declarator, list = []);
+			list.push(binding);
+		}
+		for (const [declarator, bindings] of byDeclarator) {
+			if (!bindings.some((b) => [...(info.references.get(b.name) ?? []).map((r) => r.start), ...this.outsideOf(b.name)].some((offset) => this.consumed.has(offset) && b.scope.start <= offset && offset < b.scope.end))) {
+				for (const b of bindings) removed.delete(b.id);
+				continue;
+			}
+			this.removeBindings(declarator, bindings, removed);
+		}
+		for (const declaration of info.imports) {
+			if (this.options.isOldSource(declaration.source)) continue;
+			for (const specifier of declaration.specifiers) {
+				const binding = info.bindings.find((b) => b.slot === specifier.node);
+				const refs = info.references.get(specifier.local) ?? [];
+				if (binding === void 0 || refs.length === 0) continue;
+				if (!isConsumed(info, binding, this.consumed, this.outsideOf(binding.name))) continue;
+				this.note(declaration.node.start, `${specifier.local} (from ${declaration.source}) is no longer used after the rewrite: remove the import once nothing else needs that module`);
+			}
+		}
+		let replaceable = null;
+		const removedImports = /* @__PURE__ */ new Set();
+		for (const declaration of info.imports) {
+			if (!this.options.isOldSource(declaration.source) || declaration.specifiers.length === 0) continue;
+			const kept = declaration.specifiers.filter((specifier) => {
+				const binding = info.bindings.find((b) => b.slot === specifier.node);
+				return binding === void 0 || !isConsumed(info, binding, this.consumed, this.outsideOf(binding.name));
+			});
+			if (kept.length === declaration.specifiers.length) continue;
+			for (const specifier of declaration.specifiers) {
+				if (kept.includes(specifier)) continue;
+				const binding = info.bindings.find((b) => b.slot === specifier.node);
+				if (binding !== void 0) removed.add(binding.id);
+			}
+			if (kept.length === 0) {
+				removedImports.add(declaration.node);
+				const edit = {
+					...lineRange(text, declaration.node.start, declaration.node.end),
+					text: ""
+				};
+				this.edits.push(edit);
+				replaceable ??= edit;
+			} else this.edits.push({
+				start: declaration.node.start,
+				end: declaration.node.end,
+				text: rebuildImport(text, declaration.node, kept.map((s) => s.node))
+			});
+		}
+		const locals = {
+			t: "t",
+			msg: "msg",
+			rich: "rich"
+		};
+		const needed = [];
+		const taken = /* @__PURE__ */ new Set();
+		for (const fn of [
+			"msg",
+			"rich",
+			"t"
+		]) {
+			if (!this.fns.has(fn)) continue;
+			const existing = this.existingImport(fn);
+			if (existing !== null) {
+				locals[fn] = existing;
+				taken.add(existing);
+				continue;
+			}
+			const free = (name) => !taken.has(name) && isNameFree(info, name, this.sites, removed, this.consumed) && (this.options.outside?.get(name) ?? []).every((offset) => this.consumedOutside(offset));
+			let name = ALIASES[fn].find(free);
+			for (let n = 2; name === void 0; n++) if (free(`${fn}${n}_`)) name = `${fn}${n}_`;
+			locals[fn] = name;
+			taken.add(name);
+			needed.push([fn, name]);
+		}
+		const types = {};
+		const lines = [];
+		if (needed.length > 0) {
+			const specifiers = needed.map(([fn, local]) => fn === local ? fn : `${fn} as ${local}`);
+			lines.push(`import { ${specifiers.join(", ")} } from "${RUNTIME_MODULE}";`);
+		}
+		for (const [source, names] of this.typeImports) {
+			for (const name of names) types[name] = name;
+			lines.push(`import type { ${[...names].sort().join(", ")} } from "${source}";`);
+		}
+		for (const declaration of info.imports) for (const specifier of declaration.specifiers) if (!(specifier.imported in types)) types[specifier.imported] = specifier.local;
+		if (lines.length > 0) {
+			if (replaceable !== null && this.options.placeImport === void 0) {
+				replaceable.text = lines.join("\n") + "\n";
+				replaceable.listed = false;
+			} else {
+				const edits = this.options.placeImport?.(lines.join("\n"), removedImports) ?? [importLineEdit(this.options.file, text, lines.join("\n"), info.program)];
+				for (const edit of edits) this.edits.push({
+					...edit,
+					listed: false
+				});
+			}
+		}
+		return {
+			file: this.options.file,
+			text,
+			edits: this.edits,
+			used: this.used,
+			manual: this.manual,
+			rewritten: this.rewritten,
+			locals,
+			types
+		};
+	}
+	/** Offsets of outside references (template calls) to `name`. */
+	outsideOf(name) {
+		return [...this.options.outside?.get(name) ?? []];
+	}
+	consumedOutside(offset) {
+		return this.consumed.has(offset);
+	}
+	existingImport(fn) {
+		for (const declaration of this.info.imports) {
+			if (declaration.source !== "@menapo/vi18n" || declaration.typeOnly) continue;
+			for (const specifier of declaration.specifiers) if (specifier.imported === fn && !specifier.typeOnly) return specifier.local;
+		}
+		return null;
+	}
+	/**
+	* Removes destructured hook bindings: the whole declaration when nothing
+	* of it stays (the hook's own references are then consumed too), else the
+	* properties or array slots.
+	*/
+	removeBindings(declarator, bindings, removed) {
+		const { info, text } = this.options;
+		const pattern = declarator.id;
+		if (pattern.type === "Identifier" || pattern.type === "ObjectPattern" && pattern.properties.every((p) => bindings.some((b) => b.slot === p)) || pattern.type === "ArrayPattern" && pattern.elements.every((e) => e === null || bindings.some((b) => b.slot === e))) {
+			const declaration = info.parentOf(declarator)?.node;
+			if (declaration === void 0) return;
+			const declarators = declaration.declarations;
+			const init = declarator.init;
+			if (init !== null) this.consumeRange(init);
+			if (declarators.length === 1) this.edits.push({
+				...lineRange(text, declaration.start, declaration.end),
+				text: ""
+			});
+			else this.edits.push({
+				...listItemRange(declarators, declarators.indexOf(declarator)),
+				text: ""
+			});
+			for (const b of info.bindings) if (b.declarator === declarator) removed.add(b.id);
+			return;
+		}
+		if (pattern.type === "ObjectPattern") {
+			const properties = pattern.properties;
+			const kept = properties.filter((p) => !bindings.some((b) => b.slot === p));
+			const first = properties[0];
+			const last = properties[properties.length - 1];
+			this.edits.push({
+				start: first.start,
+				end: last.end,
+				text: kept.map((p) => text.slice(p.start, p.end)).join(", ")
+			});
+			return;
+		}
+		if (pattern.type === "ArrayPattern") for (const binding of bindings) {
+			const slot = binding.slot;
+			this.edits.push({
+				start: slot.start,
+				end: slot.end,
+				text: ""
+			});
+		}
+	}
+};
+/** An import declaration printed with only `specifiers` (default, namespace, then named). */
+function rebuildImport(text, declaration, specifiers) {
+	const source = text.slice(declaration.source.start, declaration.source.end);
+	const head = [];
+	const named = [];
+	for (const specifier of specifiers) {
+		const code = text.slice(specifier.start, specifier.end);
+		if (specifier.type === "ImportSpecifier") named.push(code);
+		else head.push(code);
+	}
+	if (named.length > 0) head.push(`{ ${named.join(", ")} }`);
+	const kind = declaration.importKind === "type" ? "type " : "";
+	const end = text.slice(declaration.start, declaration.end).trimEnd().endsWith(";") ? ";" : "";
+	return `import ${kind}${head.join(", ")} from ${source}${end}`;
+}
+//#endregion
+export { keyName as _, attributeExpression as a, stringValue as b, cleanJsxText as c, isNode as d, jsString as f, jsxNameNodes as g, jsxName as h, analyzeModule as i, identifierName as l, jsxChildren as m, RUNTIME_MODULE as n, attributeString as o, jsxAttributes as p, renderPlan as r, childEntries as s, ModuleBuilder as t, inJsxChildren as u, memberParts as v, unwrap as x, objectProperties as y };