@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/vue-i18n-g0iGy6CZ.js

@@ -0,0 +1,651 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { n as printICU } from "./codec-DuvU2VQy.js";
+import { u as parseModule } from "./worker-84U6uYB3.js";
+import { f as readString, g as skipSpace, h as skipBalanced, o as importLineEdit, p as readTemplate, r as argumentEnd, y as vueRegions } from "./migrate-IpLDMXmq.js";
+import { i as analyzeModule, l as identifierName, s as childEntries, t as ModuleBuilder, v as memberParts, x as unwrap, y as objectProperties } from "./rewrite-EsIw_lsq.js";
+import { b as pushLiteral, m as flattenTree, s as entry, t as MODULE_EXTENSIONS, v as parseJson, x as yamlKeyLines, y as parseYaml } from "./i18next-BEJgv_S8.js";
+import { extname } from "node:path";
+import { readFileSync } from "node:fs";
+//#region src/cli/commands/migrate/vue-i18n.ts
+/**
+* `vi18n migrate --from vue-i18n` (INTERNALS §2.14): vue-i18n 9–11 (and the
+* v8 legacy API it keeps).
+*
+* Catalogs are JSON or YAML per locale, or one file keyed by locale; nested
+* keys join with `.`. Messages convert to ICU: `{name}` and `{0}` stay
+* arguments, `{'@'}` literals become text, linked messages (`@:key`,
+* `@.lower:key`, `@:(key)`) are inlined from the same locale, and `|`
+* pluralization becomes a plural on `count` (two forms `one`/`other`, three
+* `=0`/`one`/`other`; `{count}` and `{n}` inside are `#`). Call sites:
+* `t()`/`$t()`/`tc()`/`$tc()` in templates (interpolations and bound
+* attributes) and scripts, `i18n.global.t()`, `this.$t()`. `useI18n()`
+* bindings and imports go once unused; `<i18n-t>`, `v-t`, `$d`/`$n` and the
+* setup are reported, their messages kept in the `msg()` table.
+*/
+function isOldSource(source) {
+	return source === "vue-i18n" || source.startsWith("vue-i18n/") || source === "@intlify/core-base" || source === "petite-vue-i18n";
+}
+const MODIFIERS = {
+	upper: (s) => s.toUpperCase(),
+	lower: (s) => s.toLowerCase(),
+	capitalize: (s) => s === "" ? s : s[0].toUpperCase() + s.slice(1)
+};
+/**
+* One vue-i18n message as ICU. `linked(key)` returns the raw text of a
+* linked message in the same locale.
+*/
+function convertVueMessage(raw, linked, depth = 0) {
+	const forms = [[]];
+	let current = forms[0];
+	let i = 0;
+	const literalText = (value) => pushLiteral(current, value);
+	while (i < raw.length) {
+		const c = raw[i];
+		if (c === "{") {
+			const quote = /^\{\s*'(?:[^'\\]|\\.)*'\s*\}/.exec(raw.slice(i));
+			const close = quote === null ? raw.indexOf("}", i + 1) : i + quote[0].length - 1;
+			if (close === -1) return { error: "an unclosed {" };
+			const body = raw.slice(i + 1, close).trim();
+			i = close + 1;
+			const literal = /^'((?:[^'\\]|\\.)*)'$/.exec(body);
+			if (literal !== null) {
+				literalText(literal[1].replace(/\\(.)/g, "$1"));
+				continue;
+			}
+			if (!/^[A-Za-z_$][\w$]*$|^\d+$/.test(body)) return { error: `{${body}} is not a named or list interpolation` };
+			current.push({
+				type: "argument",
+				name: body
+			});
+			continue;
+		}
+		if (c === "@") {
+			const m = /^@(?:\.(\w+))?:(?:\(([^)]*)\)|([\w$\-.]+))/.exec(raw.slice(i));
+			if (m === null) {
+				literalText("@");
+				i++;
+				continue;
+			}
+			const modifier = m[1];
+			let key = (m[2] ?? m[3] ?? "").trim();
+			let consumed = m[0].length;
+			if (m[3] !== void 0 && key.endsWith(".") && linked(key) === void 0 && linked(key.slice(0, -1)) !== void 0) {
+				key = key.slice(0, -1);
+				consumed--;
+			}
+			i += consumed;
+			if (depth > 8) return { error: "linked messages nest deeper than 8 levels" };
+			const text = linked(key);
+			if (text === void 0) return { error: `@:${key} links to no message` };
+			const inner = convertVueMessage(text, linked, depth + 1);
+			if ("error" in inner) return inner;
+			if (inner.nodes.some((n) => n.type === "plural")) return { error: `@:${key} links to a plural message` };
+			if (modifier !== void 0) {
+				const apply = MODIFIERS[modifier];
+				if (apply === void 0) return { error: `@.${modifier}: is not a built-in modifier` };
+				if (inner.nodes.some((n) => n.type !== "literal")) return { error: `@.${modifier}:${key} changes a message with placeholders, which ICU cannot` };
+				literalText(apply(inner.nodes.map((n) => n.value).join("")));
+				continue;
+			}
+			for (const node of inner.nodes) if (node.type === "literal") literalText(node.value);
+			else current.push(node);
+			continue;
+		}
+		if (c === "|") {
+			current = [];
+			forms.push(current);
+			i++;
+			continue;
+		}
+		literalText(c);
+		i++;
+	}
+	if (forms.length === 1) return { nodes: forms[0] };
+	const trimmed = forms.map((form) => trimForm(form));
+	const keys = trimmed.length === 2 ? ["one", "other"] : trimmed.length === 3 ? [
+		"=0",
+		"one",
+		"other"
+	] : null;
+	if (keys === null) return { error: `${trimmed.length} plural forms need custom pluralRules; write the ICU plural by hand` };
+	return { nodes: [{
+		type: "plural",
+		pluralType: "cardinal",
+		name: "count",
+		offset: 0,
+		options: trimmed.map((form, index) => ({
+			key: keys[index],
+			value: form.map((node) => node.type === "argument" && (node.name === "count" || node.name === "n") ? { type: "pound" } : node)
+		}))
+	}] };
+}
+function trimForm(form) {
+	const out = form.map((n) => ({ ...n }));
+	const first = out[0];
+	if (first?.type === "literal") {
+		first.value = first.value.replace(/^\s+/, "");
+		if (first.value === "") out.shift();
+	}
+	const last = out[out.length - 1];
+	if (last?.type === "literal") {
+		last.value = last.value.replace(/\s+$/, "");
+		if (last.value === "") out.pop();
+	}
+	return out;
+}
+function createVueI18nAdapter() {
+	/** locale → key → text. */
+	const catalogs = /* @__PURE__ */ new Map();
+	const referenced = /* @__PURE__ */ new Set();
+	let sourceLocale = "";
+	const textOf = (locale, key) => catalogs.get(locale)?.get(key);
+	const add = (locale, key, value, file) => {
+		let texts = catalogs.get(locale);
+		if (texts === void 0) catalogs.set(locale, texts = /* @__PURE__ */ new Map());
+		texts.set(key, {
+			...value,
+			file
+		});
+	};
+	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 yaml = extname(file.file) === ".yaml" || extname(file.file) === ".yml";
+		const parsed = yaml ? parseYaml(text) : parseJson(text);
+		if (parsed.problem !== null) {
+			env.report("catalog-parse", parsed.problem.message, {
+				file: file.file,
+				line: parsed.problem.line
+			}, "error");
+			return;
+		}
+		const keyLines = yaml ? yamlKeyLines(text) : null;
+		const read = (tree, locale) => {
+			const flat = flattenTree(tree, yaml ? "" : text);
+			for (const problem of flat.problems) env.report("migrate-unconverted", problem.message, {
+				file: file.file,
+				line: problem.line
+			});
+			for (const [key, value] of flat.texts) {
+				const line = keyLines === null ? value.line : keyLines.get(key.split(".").pop()) ?? 0;
+				add(locale, key, {
+					value: value.value,
+					line
+				}, file.file);
+			}
+		};
+		const value = parsed.value;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			const keys = Object.keys(value);
+			const locales = keys.map((k) => env.config.locales.find((l) => l.toLowerCase() === k.toLowerCase().replace(/_/g, "-")));
+			if (keys.length > 0 && locales.every((l) => l !== void 0) && Object.values(value).every((v) => typeof v === "object" && v !== null)) {
+				keys.forEach((k, index) => read(value[k], locales[index]));
+				return;
+			}
+		}
+		read(value, file.locale);
+	};
+	/** Registers a message; its registry key, or why it cannot be. */
+	const define = (env, key, fallback) => {
+		referenced.add(key);
+		if (env.message(key) !== void 0) return { key };
+		const convert = (locale, raw) => convertVueMessage(raw, (linkedKey) => {
+			referenced.add(linkedKey);
+			return textOf(locale, linkedKey)?.value;
+		});
+		const sourceText = textOf(sourceLocale, key);
+		const raw = sourceText?.value ?? fallback;
+		if (raw === null) return { problem: `${key} is in no ${sourceLocale} catalog` };
+		const source = convert(sourceLocale, raw);
+		if ("error" in source) return { problem: `${key}: ${source.error}` };
+		const translations = /* @__PURE__ */ new Map();
+		for (const [locale, texts] of catalogs) {
+			if (locale === sourceLocale) continue;
+			const found = texts.get(key);
+			if (found === void 0) continue;
+			const converted = convert(locale, found.value);
+			translations.set(locale, "error" in converted ? {
+				unconverted: found.value,
+				reason: converted.error,
+				file: found.file,
+				line: found.line
+			} : { icu: printICU(converted.nodes) });
+		}
+		return env.define({
+			key,
+			named: true,
+			source: printICU(source.nodes),
+			context: null,
+			hint: null,
+			translations,
+			file: sourceText?.file ?? "",
+			line: sourceText?.line ?? 0
+		}) ? { key } : { problem: `${key} could not be converted` };
+	};
+	const isPluralKey = (env, key) => {
+		const message = env.message(key);
+		return message !== void 0 && message.canonical.startsWith("{count, plural,") && message.canonical.endsWith("}");
+	};
+	/** Keys a computed key can produce (string literals and matching templates in it). */
+	const keysIn = (code) => {
+		const keys = [...catalogs.get(sourceLocale)?.keys() ?? []];
+		const found = /* @__PURE__ */ new Set();
+		for (let i = 0; i < code.length; i++) {
+			const c = code[i];
+			if (c === "\"" || c === "'") {
+				const s = readString(code, i);
+				if (s === null) break;
+				if (keys.includes(s.value)) found.add(s.value);
+				i = s.end - 1;
+			} else if (c === "`") {
+				const s = readTemplate(code, i);
+				if (s === null) break;
+				if (/[A-Za-z]/.test(s.quasis.join(""))) {
+					const pattern = new RegExp("^" + s.quasis.map((q) => q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^]+?") + "$");
+					for (const key of keys) if (pattern.test(key)) found.add(key);
+				}
+				i = s.end - 1;
+			}
+		}
+		return [...found];
+	};
+	/**
+	* The values of a `t`-family call from its arguments as written (default
+	* message strings left out): `t(key, named | list | values)`,
+	* `t(key, count)` and `t(key, named | list, count)` for a plural message
+	* (`tc` always pluralizes), or why vi18n migrate cannot read them.
+	*/
+	const callValues = (env, key, args, tc) => {
+		const plural = tc || isPluralKey(env, key);
+		let named = null;
+		let list = null;
+		let count = null;
+		const [a, b] = args;
+		if (args.length > 2) return { problem: "more than two value arguments" };
+		if (a !== void 0 && b === void 0) {
+			if (a.kind === "object") named = 0;
+			else if (a.kind === "array") list = 0;
+			else if (plural) count = 0;
+			else named = 0;
+		} else if (a !== void 0 && b !== void 0) {
+			if ((a.kind === "object" || a.kind === "array") && b.kind === "other") {
+				if (a.kind === "object") named = 0;
+				else list = 0;
+				count = 1;
+			} else return { problem: "options vi18n has no counterpart for" };
+		}
+		const namedArg = named === null ? void 0 : args[named];
+		const namesCount = namedArg?.kind === "object" && /[{,]\s*count\s*[:,}]/.test(namedArg.code);
+		if (plural && count === null && !namesCount) return { problem: "a plural message without a count" };
+		return { values: (src) => {
+			const entries = [];
+			if (count !== null) entries.push(entry("count", src(count).trim()));
+			if (named !== null) {
+				const code = src(named).trim();
+				if (args[named]?.kind === "object") {
+					const inner = code.slice(1, -1).trim();
+					if (inner !== "") entries.push(inner);
+				} else if (entries.length === 0) return `, ${code}`;
+				else entries.push(`...${code}`);
+			}
+			if (list !== null) splitTopLevel(src(list).trim().slice(1, -1)).forEach((item, index) => entries.push(`${index}: ${item.trim()}`));
+			return entries.length === 0 ? "" : `, { ${entries.join(", ")} }`;
+		} };
+	};
+	const planFile = (file, text, env) => {
+		const vue = extname(file) === ".vue";
+		const regions = vue ? vueRegions(text) : null;
+		const scripts = [];
+		if (vue) for (const m of text.matchAll(/<script\b([^>]*)>/g)) {
+			const attrs = m[1];
+			if (/\bsrc\s*=/.test(attrs)) continue;
+			const start = m.index + m[0].length;
+			const close = text.indexOf("<\/script>", start);
+			if (close === -1) continue;
+			scripts.push({
+				start,
+				end: close,
+				setup: /\bsetup\b/.test(attrs),
+				lang: /\blang\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1] ?? null,
+				open: m.index
+			});
+		}
+		let code = text;
+		if (vue) {
+			code = text.replace(/[^\n]/g, " ");
+			for (const s of scripts) code = code.slice(0, s.start) + text.slice(s.start, s.end) + code.slice(s.end);
+		}
+		const lang = vue ? scripts.some((s) => s.lang === "ts" || s.lang === "tsx") ? "ts" : "js" : extname(file).includes("ts") ? "ts" : "js";
+		let program;
+		try {
+			program = parseModule(code, lang, 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 outside = /* @__PURE__ */ new Map();
+		const templateStart = text.indexOf("<template");
+		const templateEnd = text.lastIndexOf("</template>");
+		const inTemplate = (offset) => regions !== null && templateStart !== -1 && offset > templateStart && offset < templateEnd && !regions.code.some((r) => r.start <= offset && offset < r.end);
+		const templateCalls = [];
+		if (vue && regions !== null) {
+			const pattern = /(?<![\w$.-])(\$tc?|tc?|\$te|\$d|\$n|\$rt)\s*\(/g;
+			for (let m = pattern.exec(text); m !== null; m = pattern.exec(text)) {
+				if (!inTemplate(m.index) || !inExpression(text, m.index, regions)) continue;
+				const callee = m[1];
+				if (callee === "t" || callee === "tc") {
+					let list = outside.get(callee);
+					if (list === void 0) outside.set(callee, list = []);
+					list.push(m.index);
+				}
+				const call = lexicalCall(text, m.index, callee, m.index + m[0].length);
+				if (call !== null) templateCalls.push(call);
+			}
+		}
+		const blockOf = (offset) => scripts.find((s) => s.start <= offset && offset <= s.end) ?? null;
+		let plainSites = false;
+		/**
+		* The import goes into `<script setup>`, which the template sees, unless
+		* Options API code in a plain `<script>` calls `t` too: then into that
+		* block, whose imports the template sees beside a `<script setup>` (one
+		* is added, empty, when the component has none).
+		*/
+		const placeImport = vue ? (line, removed) => {
+			const setup = scripts.find((s) => s.setup);
+			const plain = scripts.find((s) => !s.setup);
+			const target = plainSites && plain !== void 0 ? plain : setup ?? null;
+			if (target === null) return [importLineEdit(file, text, line, null)];
+			const lastImport = info.imports.filter((d) => d.node.start >= target.start && d.node.end <= target.end && !removed.has(d.node)).pop();
+			const at = lastImport === void 0 ? target.start : lastImport.node.end;
+			const edits = [{
+				start: at,
+				end: at,
+				text: `\n${line}`
+			}];
+			if (target === plain && setup === void 0 && templateCalls.length > 0) {
+				const close = text.indexOf("<\/script>", plain.end) + 9;
+				const langAttr = plain.lang === null ? "" : ` lang="${plain.lang}"`;
+				edits.push({
+					start: close,
+					end: close,
+					text: `\n<script setup${langAttr}><\/script>`
+				});
+			}
+			return edits;
+		} : void 0;
+		const builder = new ModuleBuilder({
+			file,
+			text,
+			info,
+			isOldSource,
+			outside,
+			...placeImport === void 0 ? {} : { placeImport }
+		});
+		const useI18n = /* @__PURE__ */ new Set();
+		for (const declaration of info.imports) {
+			if (!isOldSource(declaration.source)) continue;
+			for (const s of declaration.specifiers) if (s.imported === "useI18n") useI18n.add(s.local);
+		}
+		const tBindings = /* @__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);
+			const callee = call.type === "CallExpression" ? identifierName(call.callee) : null;
+			if (callee === null || !useI18n.has(callee)) continue;
+			builder.hooks.push(binding);
+			const slot = binding.slot;
+			const name = slot !== null && slot.type === "Property" ? slot.key.name : null;
+			if (name === "t" || name === "tc") tBindings.add(binding);
+			const options = call.arguments[0];
+			if (options !== void 0 && objectProperties(options)?.properties.has("messages") === true) builder.note(call.start, "useI18n({ messages }) holds component-local messages, which were not migrated: move them into the locale catalogs");
+		}
+		if (vue && templateStart !== -1) for (const binding of builder.hooks) {
+			const pattern = new RegExp(String.raw`(?<![\w$.])${binding.name.replace(/\$/g, "$")}(?![\w$])`, "g");
+			for (const m of text.slice(templateStart, templateEnd).matchAll(pattern)) {
+				const offset = templateStart + m.index;
+				let list = outside.get(binding.name);
+				if (list === void 0) outside.set(binding.name, list = []);
+				if (!list.includes(offset)) list.push(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;
+		};
+		/** One `t`-family call: rewrite, note, or nothing when it is not vue-i18n's. */
+		const site = (call, known, consume, markup) => {
+			const callee = call.callee.replace(/^\$/, "");
+			if (callee === "te" || callee === "d" || callee === "n" || callee === "rt") {
+				if (known || call.callee.startsWith("$")) {
+					const hint = callee === "d" ? "use fmt.date from @menapo/vi18n" : callee === "n" ? "use fmt.number from @menapo/vi18n" : callee === "te" ? "vi18n needs no existence check, since every message the code names exists" : "translate the text with t() where it is known";
+					builder.note(call.start, `${call.callee}() is not rewritten: ${hint}`);
+				}
+				return;
+			}
+			const first = call.args[0];
+			if (first === void 0) return;
+			const firstCode = text.slice(first.start, first.end).trim();
+			const literal = /^["']/.test(firstCode) ? readString(firstCode, 0) : null;
+			let key = literal !== null && literal.end === firstCode.length ? literal.value : null;
+			if (key === null && firstCode.startsWith("`")) {
+				const t = readTemplate(firstCode, 0);
+				if (t !== null && t.quasis.length === 1 && t.end === firstCode.length) key = t.quasis[0];
+			}
+			if (key === null) {
+				const keys = keysIn(firstCode);
+				for (const k of keys) define(env, k, null);
+				if (keys.length > 0 || known) builder.note(call.start, `${call.callee}(${firstCode}) uses a computed key and was not rewritten`, keys.filter((k) => env.message(k) !== void 0));
+				return;
+			}
+			const rest = call.args.slice(1).map((a) => {
+				const argCode = text.slice(a.start, a.end).trim();
+				return {
+					code: argCode,
+					kind: argCode.startsWith("{") ? "object" : argCode.startsWith("[") ? "array" : /^["'`]/.test(argCode) ? "string" : "other",
+					range: a
+				};
+			});
+			const fallback = rest.find((a) => a.kind === "string");
+			const fallbackText = fallback === void 0 ? null : readString(fallback.code, 0)?.value ?? null;
+			if (textOf(sourceLocale, key) === void 0 && fallbackText === null) {
+				if (known) builder.note(call.start, `${call.callee}(${JSON.stringify(key)}): the key is in no ${sourceLocale} catalog; not rewritten`);
+				return;
+			}
+			const defined = define(env, key, fallbackText);
+			if ("problem" in defined) {
+				builder.note(call.start, `${defined.problem}; ${call.callee}() was not rewritten`);
+				return;
+			}
+			const values = callValues(env, key, rest.filter((a) => a.kind !== "string"), callee === "tc");
+			if ("problem" in values) {
+				builder.note(call.start, `${call.callee}(${JSON.stringify(key)}, …) passes ${values.problem}; not rewritten`, [defined.key]);
+				return;
+			}
+			const argRanges = rest.filter((a) => a.kind !== "string").map((a) => a.range);
+			for (const offset of consume.offsets) builder.consumed.add(offset);
+			if (blockOf(call.start)?.setup === false) plainSites = true;
+			builder.site(call, (r) => {
+				const src = (index) => {
+					const range = argRanges[index];
+					return r.src(range.start, range.end);
+				};
+				return `${r.fn.t}(${r.message(defined.key)}${values.values(src)})`;
+			}, {
+				keys: [defined.key],
+				uses: ["t"],
+				consume: consume.nodes,
+				...markup === null ? {} : { markup }
+			});
+		};
+		const visit = (node) => {
+			if (node.type === "CallExpression") {
+				const callee = unwrap(node.callee);
+				const args = node.arguments.map((a) => ({
+					start: a.start,
+					end: a.end
+				}));
+				let name = null;
+				let known = false;
+				let consume = [];
+				if (callee.type === "Identifier") {
+					const binding = resolve(callee.name, callee.start);
+					if (binding !== null && tBindings.has(binding)) {
+						name = callee.name;
+						known = true;
+						consume = [callee];
+					}
+				} else {
+					const member = memberParts(callee);
+					if (member !== null && /^\$?(?:tc?|te|d|n|rt)$/.test(member.property)) {
+						const object = unwrap(member.object);
+						const thisCall = object.type === "ThisExpression" && member.property.startsWith("$");
+						const global = object.type === "MemberExpression" && memberParts(object)?.property === "global";
+						if (thisCall || global || member.property === "t" || member.property === "tc") {
+							name = member.property.startsWith("$") || thisCall || global ? member.property : member.property;
+							known = thisCall || global;
+							let root = object;
+							while (root.type === "MemberExpression") root = unwrap(root.object);
+							if (root.type === "Identifier") consume = [root];
+						}
+					}
+				}
+				if (name !== null && node.arguments.every((a) => a.type !== "SpreadElement")) site({
+					callee: name,
+					calleeStart: callee.start,
+					start: node.start,
+					end: node.end,
+					args
+				}, known, {
+					nodes: consume,
+					offsets: []
+				}, null);
+				const member = memberParts(callee);
+				const calleeName = identifierName(callee);
+				if (calleeName === "createI18n" || member?.property === "use" && node.arguments.some((a) => /^i18n$/i.test(identifierName(a) ?? ""))) builder.note(node.start, calleeName === "createI18n" ? "createI18n(): delete this setup once nothing uses vue-i18n; vi18n needs only its Vite plugin and vi18n.config.ts" : "app.use(i18n): remove it with the vue-i18n setup");
+			}
+			for (const [, child] of childEntries(node)) visit(child);
+		};
+		visit(program);
+		if (vue && regions !== null) {
+			for (const call of templateCalls) {
+				const bare = call.callee === "t" || call.callee === "tc";
+				if (bare) {
+					const binding = resolve(call.callee, scripts.find((s) => s.setup)?.start ?? 0);
+					if (binding === null || !tBindings.has(binding)) {
+						if (binding !== null) continue;
+					}
+				}
+				const markup = { quote: regions.attributes.find((a) => a.start <= call.start && call.start < a.end)?.quote ?? null };
+				site(call, true, {
+					nodes: [],
+					offsets: bare ? [call.calleeStart] : []
+				}, markup);
+			}
+			for (const m of text.matchAll(/<(i18n-t|i18n|I18nT|i18n-n|i18n-d)\b([^>]*)>/g)) {
+				if (!inTemplate(m.index)) continue;
+				const attrs = m[2];
+				const keypath = /\b(?:keypath|path)\s*=\s*"([^"]*)"|\b(?:keypath|path)\s*=\s*'([^']*)'/.exec(attrs);
+				const key = keypath?.[1] ?? keypath?.[2] ?? null;
+				const keys = [];
+				if (key !== null && "key" in define(env, key, null)) keys.push(key);
+				builder.note(m.index, `<${m[1]}> is not rewritten: render rich() from @menapo/vi18n in a component (see the rich text guide)${key === null ? "" : ""}`, keys);
+			}
+			for (const m of text.matchAll(/\sv-t\s*=\s*("[^"]*"|'[^']*')/g)) {
+				if (!inTemplate(m.index)) continue;
+				const value = m[1].slice(1, -1).trim();
+				const literal = /^'([^']*)'$|^"([^"]*)"$/.exec(value);
+				const key = literal?.[1] ?? literal?.[2] ?? null;
+				const keys = key !== null && "key" in define(env, key, null) ? [key] : [];
+				builder.note(m.index + 1, "v-t is not rewritten: write {{ t(…) }} with the message", keys);
+			}
+			for (const m of text.matchAll(/^<i18n\b[^>]*>/gm)) {
+				if (inTemplate(m.index)) continue;
+				builder.note(m.index, "an <i18n> block holds component-local messages, which were not migrated: move them into the locale catalogs");
+			}
+		}
+		return builder.finish();
+	};
+	return {
+		catalogExtensions: [
+			".json",
+			".yaml",
+			".yml"
+		],
+		catalogsRequired: true,
+		extensions: /* @__PURE__ */ new Set([...MODULE_EXTENSIONS, ".vue"]),
+		mentions: (text) => /vue-i18n|\$tc?\s*\(|\bt\s*\(|i18n/.test(text),
+		load(files, env) {
+			sourceLocale = env.config.sourceLocale;
+			for (const file of files) readCatalog(file, env);
+		},
+		planFile,
+		unusedKeys() {
+			return [...catalogs.get(sourceLocale)?.keys() ?? []].filter((key) => !referenced.has(key));
+		}
+	};
+}
+/** Whether a template offset is inside `{{ }}` or the value of a bound attribute or directive. */
+function inExpression(text, offset, regions) {
+	const attribute = regions.attributes.find((a) => a.start <= offset && offset < a.end);
+	if (attribute !== void 0) {
+		const name = /([^\s"'<>/=]+)\s*=\s*$/.exec(text.slice(Math.max(0, attribute.start - 200), attribute.start - 1))?.[1];
+		return name !== void 0 && /^(?::|@|#|v-)/.test(name);
+	}
+	const open = text.lastIndexOf("{{", offset);
+	if (open === -1) return false;
+	return text.lastIndexOf("}}", offset) < open;
+}
+/** A call at `start` whose `(` ends at `open`: argument ranges as written. */
+function lexicalCall(text, start, callee, open) {
+	const close = skipBalanced(text, open - 1);
+	if (close === null) return null;
+	const args = [];
+	let at = skipSpace(text, open);
+	while (at < close - 1) {
+		const end = argumentEnd(text, at);
+		if (end === null || end > close - 1) return null;
+		args.push({
+			start: at,
+			end
+		});
+		at = skipSpace(text, end + 1);
+		if (text[end] === ")") break;
+	}
+	return {
+		callee,
+		calleeStart: start,
+		start,
+		end: close,
+		args
+	};
+}
+/** Splits `a, b, c` at top-level commas. */
+function splitTopLevel(code) {
+	const out = [];
+	let at = 0;
+	while (at < code.length) {
+		const end = argumentEnd(code + ")", at);
+		if (end === null) break;
+		const part = code.slice(at, end).trim();
+		if (part !== "") out.push(part);
+		at = end + 1;
+	}
+	return out;
+}
+//#endregion
+export { createVueI18nAdapter };