@i18n-micro/cli 0.0.0-stage → 2.0.1

package/dist/chunks/source-Bx2lHSW7.mjs

@@ -0,0 +1,744 @@
+import { m as walkFiles, n as globToRegExp, r as isUnder, s as readLoose, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { forwardSlashes } from "@i18n-micro/utils/app-path";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname, extname, relative } from "node:path";
+import { babelParse, parse as parse$1, walk } from "@vue/compiler-sfc";
+// src/source.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".vue",
+	".js",
+	".ts",
+	".jsx",
+	".tsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+]);
+/** Text no parser here reads. Keys in it still count as evidence of use. */
+var TEMPLATE_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".pug"]);
+var DATA_EXTENSIONS = /* @__PURE__ */ new Set([
+	".json",
+	".yaml",
+	".yml",
+	".md",
+	".mdx"
+]);
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".nuxt",
+	".output",
+	".data",
+	".cache",
+	".vercel",
+	".netlify",
+	".idea",
+	".vscode"
+]);
+/** Build output by these names only at a root: `pages/dist/` is a page. */
+var OUTPUT_DIRS = /* @__PURE__ */ new Set(["dist", "coverage"]);
+var SKIPPED_DATA = /^(package(-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|tsconfig.*\.json)$/;
+/** Test code by location, relative to the project root. `pages/tests/` is a route. */
+var TEST_DIR = /^(tests?|__tests__|e2e|cypress|playwright)\//;
+/** Built by a tool, wherever it sits. Here a bare `t(e)` is a minified name, not a guess worth stopping for. */
+var GENERATED_PATH = /(^|\/)(dist|\.vitepress|storybook-static)\//;
+/** Test code by name. Only code: `Latest.spec.vue` renders. */
+var TEST_NAME = /\.(test|spec)\.[cm]?[jt]sx?$/;
+var NODE_TYPES = {
+	ELEMENT: 1,
+	TEXT: 2,
+	COMMENT: 3,
+	INTERPOLATION: 5,
+	ATTRIBUTE: 6,
+	DIRECTIVE: 7
+};
+var isCodeFile = (path) => CODE_EXTENSIONS.has(extname(path).toLowerCase());
+/** The translation API by name. `bound` returns a key function for a route: `$_t(route)('key')`. */
+var DOLLAR_NAMES = [
+	["$t", "key"],
+	["$ts", "key"],
+	["$tc", "key"],
+	["$has", "guard"],
+	["$_t", "bound"],
+	["$_ts", "bound"]
+];
+/** `useI18n()` also returns these. In a file without `useI18n` a plain `t()` is somebody else's function. */
+var BARE_NAMES = [
+	["t", "key"],
+	["ts", "key"],
+	["tc", "key"],
+	["has", "guard"],
+	["_t", "bound"],
+	["_ts", "bound"]
+];
+var API_NAMES = new Map([...DOLLAR_NAMES, ...BARE_NAMES]);
+var I18N_SOURCES = /* @__PURE__ */ new Set(["useI18n", "useNuxtApp"]);
+/** Resolves to the `t` function itself. */
+var SERVER_T = "useTranslationServerMiddleware";
+var KEY_LIKE = /^[^\s'"`<>{}()]{1,200}$/;
+var asNode = (value) => value;
+var lineOf = (content, offset) => content.slice(0, Math.max(0, offset)).split("\n").length;
+function staticString(node) {
+	if (node?.type === "StringLiteral") return node.value;
+	const quasis = node?.quasis;
+	if (node?.type === "TemplateLiteral" && quasis?.length === 1) return quasis[0].value.cooked;
+	return null;
+}
+var propertyName = (callee) => {
+	return (callee?.type === "MemberExpression" || callee?.type === "OptionalMemberExpression") && !callee.computed ? asNode(callee.property)?.name ?? null : null;
+};
+/** `i18n`, `this.$i18n`, `useI18n()`: the name a member call hangs off. */
+function objectName(callee) {
+	const object = asNode(callee?.object);
+	return String(object?.name ?? asNode(object?.property)?.name ?? asNode(object?.callee)?.name ?? "");
+}
+var isI18nObject = (name, names) => name.slice(-4).toLowerCase() === "i18n" || names.objects.has(name) || I18N_SOURCES.has(name);
+function familyOf(callee, names) {
+	if (isServerT(callee)) return "key";
+	if (callee?.type === "Identifier") return names.families.get(callee.name) ?? null;
+	if (callee?.type === "CallExpression" || callee?.type === "OptionalCallExpression") return familyOf(asNode(callee.callee), names) === "bound" ? "key" : null;
+	const name = propertyName(callee);
+	if (!name) return null;
+	const family = API_NAMES.get(name) ?? null;
+	return family && (name.startsWith("$") || isI18nObject(objectName(callee), names)) ? family : null;
+}
+var unawaited = (node) => node?.type === "AwaitExpression" ? asNode(node.argument) : node;
+var isServerT = (node) => {
+	const call = unawaited(node);
+	return call?.type === "CallExpression" && asNode(call.callee)?.name === SERVER_T;
+};
+function isI18nSource(node, names) {
+	if (node?.type === "AwaitExpression") return isI18nSource(asNode(node.argument), names);
+	if (node?.type === "Identifier") return isI18nObject(node.name, names);
+	return node?.type === "CallExpression" && I18N_SOURCES.has(asNode(node.callee)?.name);
+}
+/** `useTranslationServerMiddleware(event).then((tr) => ...)`. */
+function readServerThen(node, names) {
+	const callee = asNode(node.callee);
+	if (propertyName(callee) !== "then" || !isServerT(asNode(callee?.object))) return;
+	const params = asNode(node.arguments[0])?.params;
+	if (params?.[0]) addAlias(params[0], "t", names);
+}
+function addAlias(local, original, names) {
+	const family = API_NAMES.get(original);
+	const target = local?.type === "AssignmentPattern" ? asNode(local.left) : local;
+	if (!family || target?.type !== "Identifier") return;
+	names.families.set(target.name, family);
+	names.values.add(target.name);
+}
+var keyName = (prop) => String(asNode(prop.key)?.name ?? asNode(prop.key)?.value ?? "");
+function readObjectPattern(pattern, init, names) {
+	const fromI18n = isI18nSource(init, names);
+	for (const prop of pattern.properties) {
+		if (prop.type === "RestElement" && fromI18n) names.objects.add(asNode(prop.argument)?.name);
+		if (prop.type === "RestElement") continue;
+		const original = keyName(prop);
+		const local = asNode(prop.value);
+		if (fromI18n) addAlias(local, original, names);
+		else if (API_NAMES.get(original) === "key" && local?.type === "Identifier") names.unknown.add(local.name);
+	}
+}
+var FUNCTION_NODES = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+/** `const [tr] = await Promise.all([useTranslationServerMiddleware(event)])`. */
+function holdsServerT(node) {
+	let found = false;
+	walk(node, { enter(raw) {
+		found ||= isServerT(raw);
+	} });
+	return found;
+}
+function readDeclarator(node, names) {
+	const id = asNode(node.id);
+	const init = asNode(node.init);
+	if (id?.type === "ObjectPattern") {
+		readObjectPattern(id, init, names);
+		return;
+	}
+	if (id?.type === "ArrayPattern" && init && holdsServerT(init)) {
+		for (const element of id.elements) addAlias(element ?? void 0, "t", names);
+		return;
+	}
+	if (id?.type !== "Identifier") return;
+	if (FUNCTION_NODES.has(init?.type ?? "")) {
+		names.locals.add(id.name);
+		return;
+	}
+	if (isServerT(init)) {
+		addAlias(id, "t", names);
+		return;
+	}
+	if (isI18nSource(init, names)) {
+		names.objects.add(id.name);
+		return;
+	}
+	const family = init?.type === "CallExpression" ? familyOf(asNode(init.callee), names) === "bound" ? "key" : null : familyOf(init, names);
+	if (!family) return;
+	names.families.set(id.name, family);
+	names.values.add(id.name);
+}
+/** Aliases first: a template or a later function uses what the script declares. */
+function readNames(ast, names) {
+	walk(ast, { enter(raw) {
+		const node = raw;
+		if (node.type === "VariableDeclarator") readDeclarator(node, names);
+		if (node.type === "CallExpression") readServerThen(node, names);
+		if (node.type === "AssignmentExpression") readDeclarator({
+			type: node.type,
+			id: node.left,
+			init: node.right
+		}, names);
+		if (node.type === "FunctionDeclaration") names.locals.add(asNode(node.id)?.name);
+	} });
+}
+function newNames(content) {
+	const bare = /useI18n|useTranslationServerMiddleware|i18n-?group/i.test(content);
+	return {
+		families: new Map([...DOLLAR_NAMES, ...bare ? BARE_NAMES : []]),
+		locals: /* @__PURE__ */ new Set(),
+		unknown: /* @__PURE__ */ new Set(),
+		values: new Set(DOLLAR_NAMES.map(([name]) => name)),
+		objects: /* @__PURE__ */ new Set()
+	};
+}
+var TYPE_WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"ParenthesizedExpression"
+]);
+/** `$t('a' as string)` is still the key `a`. */
+var unwrap = (node) => node && TYPE_WRAPPERS.has(node.type) ? unwrap(asNode(node.expression)) : node;
+/** `\`a.${x}\`` and `'a.' + x` both pin down `a.`. */
+function staticPrefix(node) {
+	if (node?.type === "BinaryExpression") return staticPrefix(asNode(node.left));
+	return (node?.quasis)?.[0]?.value.cooked ?? staticString(node) ?? "";
+}
+function addRef(literal, node, context, extra, inGroup) {
+	const { base, content, file, group, keyNodes, scan } = context;
+	keyNodes.add(node);
+	const start = base + node.start + 1;
+	const keyPrefix = inGroup ? `${group.prefix}.` : void 0;
+	scan.refs.push({
+		key: `${keyPrefix ?? ""}${literal}`,
+		file,
+		line: lineOf(content, start),
+		start,
+		end: start + literal.length,
+		keyPrefix,
+		...extra
+	});
+}
+function addArgument(wrapped, context, extra, inGroup) {
+	const argument = unwrap(wrapped);
+	if (!argument) return;
+	const literal = staticString(argument);
+	if (literal !== null) {
+		addRef(literal, argument, context, extra, inGroup);
+		return;
+	}
+	if (argument.type === "ConditionalExpression") {
+		addArgument(asNode(argument.consequent), context, extra, inGroup);
+		addArgument(asNode(argument.alternate), context, extra, inGroup);
+		return;
+	}
+	if (argument.type === "LogicalExpression") {
+		addArgument(asNode(argument.left), context, extra, inGroup);
+		addArgument(asNode(argument.right), context, extra, inGroup);
+		return;
+	}
+	const { base, content, file, scan, group } = context;
+	const start = base + argument.start;
+	const prefix = `${inGroup ? `${group.prefix}.` : ""}${staticPrefix(argument)}`;
+	scan.dynamic.push({
+		file,
+		line: lineOf(content, start),
+		expression: content.slice(start, base + argument.end),
+		prefix
+	});
+}
+function addLiteral(text, scan, location) {
+	if (!KEY_LIKE.test(text)) return;
+	if (text.endsWith(".")) scan.prefixes.add(text);
+	else scan.literals.set(text, [...scan.literals.get(text) ?? [], location]);
+}
+var NOT_A_GUARD = { guard: false };
+function addOpaque(expression, node, context, guess = false) {
+	const { base, content, file, scan } = context;
+	scan.dynamic.push({
+		file,
+		line: lineOf(content, base + node.start),
+		expression,
+		prefix: "",
+		guess
+	});
+}
+/** `I18nT`, `i18n-t`, and the `Lazy` form Nuxt registers for every component. */
+var TAG_HEADS = [
+	"i18n",
+	"i18n-",
+	"lazyi18n",
+	"lazyi18n-",
+	"lazy-i18n",
+	"lazy-i18n-"
+];
+var KEY_TAGS = new Set(TAG_HEADS.map((head) => `${head}t`));
+var GROUP_TAGS = new Set(TAG_HEADS.map((head) => `${head}group`));
+var isKeyTag = (tag) => KEY_TAGS.has(tag.toLowerCase());
+var isGroupTag = (tag) => GROUP_TAGS.has(tag.toLowerCase());
+var isTranslationTag = (tag) => isKeyTag(tag) || isGroupTag(tag);
+var RENDER_FUNCTIONS = /* @__PURE__ */ new Set(["h", "createVNode"]);
+function componentName(node) {
+	if (node?.type === "CallExpression") return staticString(node.arguments[0]) ?? "";
+	return String(node?.name ?? staticString(node) ?? "");
+}
+/** `h(I18nT, props)`: the key is in an object this code does not spell out. */
+function visitRender(node, context) {
+	if (!RENDER_FUNCTIONS.has(asNode(node.callee)?.name)) return;
+	const [component, props] = node.arguments;
+	const name = componentName(component);
+	if (!isTranslationTag(name) || !props) return;
+	if (!(props.type === "ObjectExpression" && !props.properties.some((prop) => prop.type === "SpreadElement"))) addOpaque(`h(${name}, ...)`, props, context);
+}
+/** `<i18n-t keypath={x} />` and `<i18n-t {...x} />` in JSX. */
+function visitJsx(node, context) {
+	const tag = String(asNode(node.name)?.name ?? "");
+	if (!isTranslationTag(tag)) return;
+	const attributes = node.attributes;
+	for (const attribute of attributes) {
+		if (attribute.type === "JSXSpreadAttribute") addOpaque(`<${tag} {...}>`, attribute, context);
+		if (attribute.type !== "JSXAttribute") continue;
+		const name = asNode(attribute.name)?.name;
+		const value = asNode(attribute.value);
+		if (name === "keypath" || name === "prefix") addArgument(value?.type === "JSXExpressionContainer" ? asNode(value.expression) : value, context, NOT_A_GUARD, false);
+	}
+}
+/** A `keypath` in an object is a key on its way to `<i18n-t>`: `h(I18nT, { keypath })`, `v-bind="{ keypath }"`. */
+function visitProperty(node, context) {
+	if (keyName(node) === "keypath" && !node.computed) addArgument(asNode(node.value), context, NOT_A_GUARD, false);
+}
+/** `t(name)` with `t` from a parameter, an import or a call: a wrapper composable, most likely. It may be a translation. */
+var BARE_KEY_CALL = new Set(BARE_NAMES.filter(([, family]) => family === "key").map(([name]) => name));
+function visitUnknownCall(callee, argument, context) {
+	const target = unwrap(argument);
+	if (callee?.type !== "Identifier" || !target || staticString(target) !== null) return;
+	const name = callee.name;
+	if ((BARE_KEY_CALL.has(name) || context.names.unknown.has(name)) && !context.names.locals.has(name)) addOpaque(`${name}(...) of unknown origin`, target, context, true);
+}
+function visitCall(node, context) {
+	const callee = asNode(node.callee);
+	const inGroup = callee?.type === "Identifier" && Boolean(context.group?.names.has(callee.name));
+	const family = inGroup ? "key" : familyOf(callee, context.names);
+	if (family === null) visitUnknownCall(callee, node.arguments[0], context);
+	if (family !== "key" && family !== "guard") return;
+	const [key, , fallback] = node.arguments;
+	addArgument(key, context, {
+		guard: family === "guard",
+		defaultText: staticString(fallback) ?? void 0
+	}, inGroup);
+}
+/** `$t.call(null, k)`: the function itself, handed to something else. */
+var FUNCTION_METHODS = /* @__PURE__ */ new Set([
+	"call",
+	"apply",
+	"bind"
+]);
+/** Where a name only stands for itself: a declaration, a parameter, a property, a type. */
+function isValueUse(parent, key, declared, node) {
+	if (key === "object" && parent) return FUNCTION_METHODS.has(propertyName(parent) ?? "");
+	if (!parent || declared.has(node) || key === "callee" || key === "params" || key === "id") return false;
+	if ((key === "key" || key === "property") && !parent.computed) return false;
+	if (parent.type.startsWith("Import") || parent.type.startsWith("Export")) return false;
+	if (parent.type === "UnaryExpression" && parent.operator === "typeof") return false;
+	return !parent.type.startsWith("TS") || key === "expression";
+}
+function declare(node, declared) {
+	if (!node) return;
+	declared.add(node);
+	if (node.type === "ObjectPattern") for (const prop of node.properties) declare(asNode(prop.value) ?? prop, declared);
+	if (node.type === "ArrayPattern") for (const element of node.elements) declare(element ?? void 0, declared);
+	if (node.type === "AssignmentPattern") declare(asNode(node.left), declared);
+	if (node.type === "RestElement") declare(asNode(node.argument), declared);
+}
+function visitNode(node, parent, key, context, declared) {
+	const { base, content, file, names, scan } = context;
+	if (node.type === "VariableDeclarator") declare(asNode(node.id), declared);
+	if (Array.isArray(node.params)) for (const param of node.params) declare(param, declared);
+	if (node.type === "CallExpression" || node.type === "OptionalCallExpression") visitCall(node, context);
+	if (node.type === "CallExpression") visitRender(node, context);
+	if (node.type === "JSXOpeningElement") visitJsx(node, context);
+	if (node.type === "ObjectProperty") visitProperty(node, context);
+	const literal = staticString(node);
+	if (literal !== null && !context.keyNodes.has(node)) addLiteral(literal, scan, `${file}:${lineOf(content, base + node.start)}`);
+	if (node.type === "TemplateLiteral" && literal === null) addLiteral(staticPrefix(node), scan, file);
+	if (node.type !== "Identifier" || !names.values.has(node.name) || !isValueUse(parent, key, declared, node)) return;
+	const start = base + node.start;
+	scan.dynamic.push({
+		file,
+		line: lineOf(content, start),
+		expression: `${node.name} passed as a value`,
+		prefix: ""
+	});
+}
+function visitCode(ast, context) {
+	const declared = /* @__PURE__ */ new WeakSet();
+	walk(ast, { enter(raw, parent, key) {
+		visitNode(raw, parent, key, context, declared);
+	} });
+}
+/** JSX only where the file allows it: in plain TypeScript `<string>x` is a cast. */
+function tryParse(code, plugins) {
+	try {
+		return babelParse(code, {
+			sourceType: "module",
+			errorRecovery: true,
+			plugins
+		});
+	} catch {
+		return null;
+	}
+}
+var isClean = (ast) => Boolean(ast) && !ast.errors?.length;
+/**
+* The syntax tree, or `null` when the code does not parse. A file with a recoverable error
+* (a duplicate declaration, say) still gives a whole tree; `strict` refuses it, for telling
+* an expression from a statement.
+*/
+function parseCode(code, lang = "ts", strict = false) {
+	const first = tryParse(code, lang.endsWith("x") ? [
+		"typescript",
+		"jsx",
+		"decorators"
+	] : ["typescript", "decorators"]);
+	if (isClean(first)) return first;
+	const retry = lang === "js" || lang === "cjs" || lang === "mjs" ? tryParse(code, ["jsx", "decorators"]) : null;
+	if (isClean(retry)) return retry;
+	return strict ? null : first ?? retry;
+}
+var TEXT_CALL = /(?:\$tc?s?|\$has|\btc?s?)\s*\(\s*(?:['"`]([^'"`$]+)['"`]|([^'"`)\s][^)]*))/g;
+var QUOTED = /['"`]([^'"`\n]+)['"`]/g;
+/** For what no parser here reads, such as Pug templates: finding a key too many is the safe mistake. */
+function collectFromText(text, context, base, bareCalls = true) {
+	const { content, file, scan } = context;
+	for (const match of text.matchAll(TEXT_CALL)) {
+		const line = lineOf(content, base + match.index);
+		if (match[1]) scan.refs.push({
+			key: match[1],
+			file,
+			line,
+			start: -1,
+			end: -1,
+			guard: false
+		});
+		else if (bareCalls || match[0][0] === "$") scan.dynamic.push({
+			file,
+			line,
+			expression: match[2].trim(),
+			prefix: ""
+		});
+	}
+	for (const match of text.matchAll(QUOTED)) addLiteral(match[1], scan, `${file}:${lineOf(content, base + match.index)}`);
+}
+function unproven(context, text, base, reason) {
+	context.scan.unproven.push(reason);
+	collectFromText(text, context, base);
+}
+function scanExpression(expression, offset, context) {
+	const wrapped = parseCode(`(${expression}\n)`, "ts", true);
+	const ast = wrapped ?? parseCode(expression);
+	if (!ast) {
+		unproven(context, expression, offset, `unparsed template expression at line ${lineOf(context.content, offset)}`);
+		return;
+	}
+	visitCode(ast, {
+		...context,
+		base: wrapped ? offset - 1 : offset
+	});
+}
+function addKeypathAttribute(prop, context) {
+	const { file, content, scan } = context;
+	const { value } = prop;
+	const quote = value.loc.source[0] === "'" || value.loc.source[0] === "\"" ? 1 : 0;
+	const start = value.loc.start.offset + quote;
+	scan.refs.push({
+		key: value.content,
+		file,
+		line: lineOf(content, start),
+		start,
+		end: start + value.content.length,
+		guard: false
+	});
+}
+function addGroupPrefix(prop, tag, context) {
+	const { file, content, scan } = context;
+	const line = lineOf(content, prop.value.loc.start.offset);
+	scan.dynamic.push({
+		file,
+		line,
+		expression: `<${tag} prefix="${prop.value.content}">`,
+		prefix: prop.value.content,
+		group: true
+	});
+}
+function readAttribute(prop, tag, context) {
+	if (!prop.value) return;
+	if (prop.name === "keypath" && isKeyTag(tag)) addKeypathAttribute(prop, context);
+	else if (prop.name === "prefix" && isGroupTag(tag)) addGroupPrefix(prop, tag, context);
+	else addLiteral(prop.value.content, context.scan, `${context.file}:${lineOf(context.content, prop.value.loc.start.offset)}`);
+}
+/** `v-slot="{ t: tr }"` of an `<i18n-group>`: what the block calls the scoped `t`. */
+function readSlotNames(expression, group) {
+	const ast = parseCode(`(${expression}\n)=>0`);
+	if (!ast) return;
+	walk(ast, { enter(raw) {
+		const node = raw;
+		if (node.type !== "ObjectProperty" || asNode(node.key)?.name !== "t") return;
+		const local = asNode(node.value);
+		if (local?.type === "Identifier") group.names.add(local.name);
+	} });
+}
+/** `<i18n-t :keypath />` and `<i18n-t v-bind="p" />`: the key is somewhere the template does not show. */
+function readHiddenKey(prop, tag, context) {
+	const translates = isTranslationTag(tag);
+	const target = prop.arg?.content;
+	const hidden = prop.name === "bind" && (target === void 0 || !prop.exp?.content && (target === "keypath" || target === "prefix"));
+	if (!translates || !hidden) return;
+	const { content, file, scan } = context;
+	const line = lineOf(content, prop.loc.start.offset);
+	scan.dynamic.push({
+		file,
+		line,
+		expression: `<${tag} ${prop.loc.source}>`,
+		prefix: ""
+	});
+}
+function readDirective(prop, tag, context) {
+	readHiddenKey(prop, tag, context);
+	const expression = prop.forParseResult?.source ?? prop.exp;
+	if (!expression?.content) return;
+	const start = expression.loc.start.offset;
+	if (prop.name === "slot") {
+		if (context.group) readSlotNames(expression.content, context.group);
+		return;
+	}
+	const argument = prop.arg?.content;
+	if (argument === "keypath" && isKeyTag(tag)) {
+		const ast = parseCode(`$t(${expression.content}\n)`);
+		if (ast) visitCode(ast, {
+			...context,
+			base: start - 3
+		});
+		else unproven(context, expression.content, start, `unparsed :keypath at line ${lineOf(context.content, start)}`);
+		return;
+	}
+	if (argument === "prefix" && isGroupTag(tag)) {
+		const line = lineOf(context.content, start);
+		context.scan.dynamic.push({
+			file: context.file,
+			line,
+			expression: expression.content,
+			prefix: ""
+		});
+	}
+	scanExpression(expression.content, start, context);
+}
+/** `<component :is="'i18n-t'">` is an `<i18n-t>`, and so is a dynamic `is` that gets a `keypath`. */
+function tagOf(node) {
+	if (node.tag !== "component") return node.tag ?? "";
+	const is = node.props?.find((prop) => prop.name === "is" || prop.arg?.content === "is");
+	const named = (is?.value?.content ?? is?.exp?.content ?? "").replace(/^['"`]|['"`]$/g, "");
+	return node.props?.some((prop) => prop.name === "keypath" || prop.arg?.content === "keypath") ? "i18n-t" : named;
+}
+function groupOf(node, context) {
+	if (!isGroupTag(tagOf(node))) return context;
+	const prefix = node.props?.find((prop) => prop.type === NODE_TYPES.ATTRIBUTE && prop.name === "prefix")?.value?.content;
+	return prefix ? {
+		...context,
+		group: {
+			prefix,
+			names: /* @__PURE__ */ new Set()
+		}
+	} : context;
+}
+function visitTemplate(node, outer) {
+	if (node.type === NODE_TYPES.INTERPOLATION && node.content?.content) scanExpression(node.content.content, node.content.loc.start.offset, outer);
+	const context = node.type === NODE_TYPES.ELEMENT ? groupOf(node, outer) : outer;
+	if (node.type === NODE_TYPES.ELEMENT) for (const prop of node.props ?? []) {
+		if (prop.type === NODE_TYPES.ATTRIBUTE) readAttribute(prop, tagOf(node), context);
+		if (prop.type === NODE_TYPES.DIRECTIVE) readDirective(prop, tagOf(node), context);
+	}
+	for (const child of node.children ?? []) visitTemplate(child, context);
+}
+function scanVue(content, context) {
+	const { descriptor, errors } = parse$1(content, { filename: context.file });
+	const { template, script, scriptSetup } = descriptor;
+	if (errors.length > 0) context.scan.unproven.push(`SFC parse error: ${String(errors[0].message)}`);
+	const blocks = [script, scriptSetup].flatMap((block) => block ? [{
+		block,
+		ast: parseCode(block.content, block.lang ?? "ts")
+	}] : []);
+	for (const { ast } of blocks) if (ast) readNames(ast, context.names);
+	for (const { block, ast } of blocks) if (ast) visitCode(ast, {
+		...context,
+		base: block.loc.start.offset
+	});
+	else unproven(context, block.content, block.loc.start.offset, `unparsed <script> in ${basename(context.file)}`);
+	if (template?.ast && (!template.lang || template.lang === "html")) visitTemplate(template.ast, context);
+	else if (template) collectFromText(template.content, context, template.loc.start.offset);
+}
+function scanCode(content, context) {
+	const ast = parseCode(content, extname(context.file).slice(1).toLowerCase());
+	if (!ast) {
+		unproven(context, content, 0, `parse error in ${basename(context.file)}`);
+		return;
+	}
+	readNames(ast, context.names);
+	visitCode(ast, context);
+}
+/** Every use of a translation key in one file, with positions. Comments do not count. */
+function scanFile(content, file) {
+	const scan = {
+		refs: [],
+		dynamic: [],
+		literals: /* @__PURE__ */ new Map(),
+		prefixes: /* @__PURE__ */ new Set(),
+		unproven: []
+	};
+	const context = {
+		content,
+		file,
+		scan,
+		names: newNames(content),
+		base: 0,
+		group: null,
+		keyNodes: /* @__PURE__ */ new WeakSet()
+	};
+	const extension = extname(file).toLowerCase();
+	if (content.trim() === "") return scan;
+	if (extension === ".vue") scanVue(content, context);
+	else if (CODE_EXTENSIONS.has(extension)) scanCode(content, context);
+	else collectFromText(content, context, 0, false);
+	return scan;
+}
+var SEGMENT_TOKEN = /\[{1,2}(?:\.\.\.)?([^\]]+)\]{1,2}/g;
+/** Route name Nuxt gives a page file: the name of its `locales/pages/<name>/` directory. */
+function pageNameOf(pagePath) {
+	const segments = forwardSlashes(pagePath).replace(/\.[^./]+$/, "").replace(/\.(client|server)$/, "").split("/").filter((segment) => !(segment.length > 1 && segment[0] === "(" && segment.endsWith(")"))).map((segment) => segment.replace(SEGMENT_TOKEN, "$1"));
+	if (segments.at(-1) === "index" && segments.length > 1) segments.pop();
+	return segments.join("-") || "index";
+}
+var PAGE_META_NAME = /definePageMeta\(\s*\{[^}]*?\bname:\s*['"`]([^'"`]+)['"`]/;
+function pageScopeOf(file, pagesRoot, content) {
+	return content.match(PAGE_META_NAME)?.[1] ?? pageNameOf(relative(pagesRoot, file));
+}
+var DATA_TOKEN = /[\p{L}\p{N}_$-]+(?:\.[\p{L}\p{N}_$-]+)*/gu;
+/** Evidence only, never saved: a stray byte in a notes file must not stop anything. */
+var dataTokensOf = (path) => Array.from(readLoose(path).matchAll(DATA_TOKEN), (match) => match[0]);
+function collectData(path, scan) {
+	scan.dataFiles.push(path);
+	for (const token of dataTokensOf(path)) scan.dataTokens.add(token);
+}
+/** Everything of the project a key can hide in, once each, whatever folder it lives in. */
+function projectFiles(config, options = {}) {
+	const excluded = new Set(config.translationDirs);
+	const ignored = (options.ignore ?? []).map(globToRegExp);
+	const isIgnored = (path) => {
+		const rel = relativePath(config.rootDir, path);
+		return ignored.some((pattern) => pattern.test(rel));
+	};
+	const accept = (path) => {
+		const extension = extname(path).toLowerCase();
+		return (CODE_EXTENSIONS.has(extension) || TEMPLATE_EXTENSIONS.has(extension) || DATA_EXTENSIONS.has(extension)) && !path.endsWith(".d.ts") && !SKIPPED_DATA.test(basename(path)) && !isIgnored(path);
+	};
+	const roots = [.../* @__PURE__ */ new Set([
+		config.rootDir,
+		config.srcDir,
+		...config.layerRoots,
+		...config.extraSourceDirs
+	])];
+	const skipDir = (path) => SKIPPED_DIRS.has(basename(path)) || OUTPUT_DIRS.has(basename(path)) && roots.includes(dirname(path)) || excluded.has(path) || isIgnored(path);
+	const seen = new Set(config.translationDirs.flatMap((dir) => walkFiles(dir, (path) => path.endsWith(".json")).map((file) => realpathSync(file))));
+	return roots.flatMap((root) => walkFiles(root, accept, skipDir)).filter((file) => {
+		const real = realpathSync(file);
+		return seen.has(real) ? false : Boolean(seen.add(real));
+	});
+}
+var inTestDir = (config, file) => TEST_DIR.test(relativePath(config.rootDir, file));
+var isTestFile = (config, file) => inTestDir(config, file) || TEST_NAME.test(file);
+var AVERAGE_LINE_OF_A_BUNDLE = 1e3;
+var isMinified = (file, content) => file.endsWith(".min.js") || file.endsWith(".min.mjs") || file.endsWith(".min.cjs") || content.length / content.split("\n").length > AVERAGE_LINE_OF_A_BUNDLE;
+var isServedAsIs = (config, file, content) => [config.rootDir, config.srcDir].some((root) => relativePath(root, file).startsWith("public/")) || isMinified(file, content);
+function addFile(file, config, out) {
+	const content = readFileSync(file, "utf8");
+	const found = scanFile(content, file);
+	const pagesRoot = config.pagesDirs.find((dir) => isUnder(dir, file));
+	const page = pagesRoot && isCodeFile(file) ? pageScopeOf(file, pagesRoot, content) : null;
+	const test = !page && isTestFile(config, file);
+	for (const ref of found.refs) out.refs.push({
+		...ref,
+		page,
+		test
+	});
+	for (const [text, locations] of found.literals) out.literals.set(text, [...out.literals.get(text) ?? [], ...locations]);
+	for (const prefix of found.prefixes) out.prefixes.add(prefix);
+	out.files += 1;
+	if (!page && (inTestDir(config, file) || isServedAsIs(config, file, content))) return;
+	const generated = !page && GENERATED_PATH.test(relativePath(config.rootDir, file));
+	out.dynamic.push(...found.dynamic.filter((entry) => !(generated && entry.guess)));
+	for (const reason of found.unproven) out.unproven.push({
+		file,
+		reason
+	});
+}
+/**
+* Whether a write may touch this source. The scan reads layers and alias targets to prove use;
+* they belong to whoever else builds on them, and their locale files stay as they are.
+*/
+function isOwnSource(config, file) {
+	const real = realpathSync(file);
+	const project = realpathSync(config.rootDir);
+	const nested = config.layerRoots.filter((root) => existsSync(root)).map((root) => realpathSync(root)).filter((root) => root !== project && isUnder(project, root));
+	return isUnder(project, real) && !forwardSlashes(real.slice(project.length)).includes("/node_modules/") && !nested.some((root) => isUnder(root, real));
+}
+function scanProject(config, options = {}) {
+	const out = {
+		refs: [],
+		dynamic: [],
+		literals: /* @__PURE__ */ new Map(),
+		prefixes: /* @__PURE__ */ new Set(),
+		dataTokens: /* @__PURE__ */ new Set(),
+		dataFiles: [],
+		unproven: [],
+		files: 0
+	};
+	for (const file of projectFiles(config, options)) if (DATA_EXTENSIONS.has(extname(file).toLowerCase())) collectData(file, out);
+	else addFile(file, config, out);
+	return out;
+}
+var parentsOf = (key) => {
+	const parts = key.split(".");
+	return parts.slice(1).map((_part, index) => parts.slice(0, index + 1).join("."));
+};
+/**
+* Whether a key may be read. One answer for `clean`, `check` and `search`.
+*
+* Any trace counts, not only a call: a string equal to the key can reach `$t` through a
+* variable, a prop or a data file. A dead key that stays is a line of noise; a live key that
+* goes is a broken page.
+*/
+function usageIndex(scan) {
+	const called = new Set(scan.refs.map((ref) => ref.key));
+	const passedThrough = new Set(scan.refs.flatMap((ref) => parentsOf(ref.key)));
+	const prefixes = [...scan.prefixes, ...scan.dynamic.map((entry) => entry.prefix).filter(Boolean)];
+	return (key) => called.has(key) || passedThrough.has(key) || scan.literals.has(key) || scan.dataTokens.has(key) || parentsOf(key).some((parent) => called.has(parent)) || prefixes.some((prefix) => key.startsWith(prefix));
+}
+/** Why "no source file uses this key" cannot be trusted in this project. Empty when it can. */
+function usageDoubts(scan) {
+	return [
+		...scan.dynamic.filter((entry) => !entry.prefix).map(({ file, line, expression }) => `Key computed at runtime in ${file}:${line}: ${expression}`),
+		...scan.unproven.map(({ file, reason }) => `Could not read ${file}: ${reason}`),
+		...scan.refs.length === 0 ? ["No source file uses any key: the scan is probably looking in the wrong place."] : []
+	];
+}
+export { isTestFile as a, projectFiles as c, staticString as d, usageDoubts as f, isOwnSource as i, scanFile as l, dataTokensOf as n, lineOf as o, usageIndex as p, isCodeFile as r, parseCode as s, NODE_TYPES as t, scanProject as u };