@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/captured-Bj8bO6vd.js

@@ -0,0 +1,1034 @@
+import { a as isIgnored, c as unwrap, d as listImports, o as markersOf, s as keyName } from "./sources-D19czDSA.js";
+//#region src/core/extract/hooks.ts
+/** `HELPER.useT` in `src/vite/types.ts`; core does not import the plugin layer. */
+const USE_T = "__vi18nUseT";
+/** `VIRTUAL.glue` in `src/vite/types.ts`. */
+const GLUE = "virtual:vi18n/glue/";
+/** Preferred local of the `__vi18nUseT` import: hook-shaped, see the module comment. */
+const USE_T_LOCAL = "useVi18nT";
+/** `HELPER.hookLocal` in `src/vite/types.ts`. */
+const HOOK_LOCAL = "__t";
+/** React Compiler's opt-out directives, which also opt out of the hook (PLAN §5.15). */
+const NO_MEMO = /* @__PURE__ */ new Set(["use no memo", "use no forget"]);
+const NO_HOOK_COMMENT = "vi18n-no-hook";
+/** Modules whose `createElement`/`jsx` calls are compiled JSX (code that reached the pass already compiled). */
+const JSX_MODULES = /* @__PURE__ */ new Set([
+	"react",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"preact",
+	"preact/compat",
+	"preact/jsx-runtime",
+	"preact/jsx-dev-runtime"
+]);
+const JSX_FACTORIES = /* @__PURE__ */ new Set([
+	"jsx",
+	"jsxs",
+	"jsxDEV",
+	"createElement",
+	"h"
+]);
+/** Wrappers whose function argument is still the component (`memo(function Card() {…})`). */
+const COMPONENT_WRAPPERS = /* @__PURE__ */ new Set(["memo", "forwardRef"]);
+/**
+* Array methods that call their callback as a plain function: a component
+* passed to them (`rows.map(Row)`) is not rendered as an element.
+*/
+const PLAIN_CALLERS = /* @__PURE__ */ new Set([
+	"call",
+	"apply",
+	"map",
+	"flatMap",
+	"forEach",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"some",
+	"every",
+	"reduce",
+	"reduceRight",
+	"from"
+]);
+/** Keys that hold only TypeScript types; nothing under them runs. */
+const TYPE_KEYS$1 = /* @__PURE__ */ new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"typeArguments",
+	"superTypeArguments",
+	"returnType",
+	"implements"
+]);
+/** `rich`-like members of a namespace import; `fmt` is an object whose members are called. */
+const NAMESPACE_TRACKED = /* @__PURE__ */ new Set([
+	"rich",
+	"richHtml",
+	"richParts"
+]);
+/** Function methods: `rich.call(…)` is already the tracked shape, never a member to wrap. */
+const FUNCTION_METHODS = /* @__PURE__ */ new Set([
+	"call",
+	"apply",
+	"bind"
+]);
+function isHookName(name) {
+	if (name.length < 4 || !name.startsWith("use")) return false;
+	const c = name.charCodeAt(3);
+	return c >= 65 && c <= 90 || c >= 48 && c <= 57;
+}
+function isComponentName(name) {
+	const c = name.charCodeAt(0);
+	return c >= 65 && c <= 90;
+}
+function isFunction$1(node) {
+	return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function isIdentifierChar(c) {
+	return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 36 || c === 95 || c > 127;
+}
+/** True when `name` occurs in `code` as a whole identifier-like word (strings and comments included: a false hit only renames). */
+function mentions(code, name) {
+	for (let at = code.indexOf(name); at !== -1; at = code.indexOf(name, at + 1)) if ((at === 0 || !isIdentifierChar(code.charCodeAt(at - 1))) && (at + name.length === code.length || !isIdentifierChar(code.charCodeAt(at + name.length)))) return true;
+	return false;
+}
+function freeName(code, base) {
+	if (!mentions(code, base)) return base;
+	for (let i = 2;; i++) if (!mentions(code, base + i)) return base + i;
+}
+/** Offset of the first character after whitespace and comments, from `at`, never past `limit`. */
+function skipTrivia(code, at, limit) {
+	let i = at;
+	while (i < limit) {
+		const c = code.charCodeAt(i);
+		if (c === 47 && code.charCodeAt(i + 1) === 42) {
+			const close = code.indexOf("*/", i + 2);
+			i = close === -1 ? limit : close + 2;
+		} else if (c === 47 && code.charCodeAt(i + 1) === 47) {
+			const close = code.indexOf("\n", i + 2);
+			i = close === -1 ? limit : close + 1;
+		} else if (c === 32 || c === 9 || c === 10 || c === 13 || c === 160 || c === 65279) i++;
+		else if (c === 8232 || c === 8233 || c > 127 && /\s/.test(code[i])) i++;
+		else break;
+	}
+	return i;
+}
+/** True when a comment in `code[from, to)` contains `vi18n-no-hook`. */
+function optedOut(code, from, to) {
+	const region = code.slice(from, to);
+	let at = region.indexOf(NO_HOOK_COMMENT);
+	while (at !== -1) {
+		const open = region.lastIndexOf("/*", at);
+		if (open !== -1 && region.indexOf("*/", open + 2) >= at + 13) return true;
+		const line = region.lastIndexOf("\n", at) + 1;
+		if (region.slice(line, at).includes("//")) return true;
+		at = region.indexOf(NO_HOOK_COMMENT, at + 1);
+	}
+	return false;
+}
+/** The leading directives of a statement list (`"use client"`, `"use no memo"`). */
+function directives(statements) {
+	let n = 0;
+	while (n < statements.length && typeof statements[n].directive === "string") n++;
+	return statements.slice(0, n);
+}
+function hasNoMemo(statements) {
+	for (const d of directives(statements)) if (NO_MEMO.has(d.directive)) return true;
+	return false;
+}
+/** The function a wrapper call (`memo(…)`, `React.forwardRef(…)`, nested) wraps, if any. */
+function wrappedFunction(init) {
+	let node = unwrap(init);
+	for (let depth = 0; depth < 4; depth++) {
+		if (isFunction$1(node)) return node;
+		if (node.type !== "CallExpression") return null;
+		const callee = unwrap(node.callee);
+		const name = callee.type === "Identifier" ? callee.name : callee.type === "MemberExpression" ? keyName(callee.property, callee.computed === true) : null;
+		if (name === null || !COMPONENT_WRAPPERS.has(name)) return null;
+		const first = node.arguments[0];
+		if (first === void 0 || first.type === "SpreadElement") return null;
+		node = unwrap(first);
+	}
+	return null;
+}
+/**
+* Named functions declared at the top level: function declarations
+* (exported or not), `const X = <function>` and `const X = memo(<function>)`
+* (also `forwardRef`, nested), `export default memo(function X() {…})`, and
+* anonymous default exports (named `"default"`, flagged `anonymous`).
+* `regionStart` is where comments leading the declaration may start (the end
+* of the previous statement or declarator). Shared with `captured.ts`, which
+* finds Solid components the same way.
+*/
+function topLevelFunctions(program) {
+	const out = [];
+	let previousEnd = 0;
+	for (const statement of program.body) {
+		const regionStart = previousEnd;
+		previousEnd = statement.end;
+		let node = statement;
+		if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+			const declaration = node.declaration;
+			if (declaration === null) continue;
+			node = declaration;
+		}
+		switch (node.type) {
+			case "FunctionDeclaration": {
+				const id = node.id;
+				if (node.body === null) break;
+				if (id !== null) out.push({
+					name: id.name,
+					fn: node,
+					regionStart
+				});
+				else out.push({
+					name: "default",
+					anonymous: true,
+					fn: node,
+					regionStart
+				});
+				break;
+			}
+			case "VariableDeclaration": {
+				let start = regionStart;
+				for (const declarator of node.declarations) {
+					const id = declarator.id;
+					const init = declarator.init;
+					const fn = init === null ? null : wrappedFunction(init);
+					if (id.type === "Identifier" && fn !== null) out.push({
+						name: id.name,
+						fn,
+						regionStart: start
+					});
+					start = declarator.end;
+				}
+				break;
+			}
+			default: {
+				if (statement.type !== "ExportDefaultDeclaration") break;
+				const fn = wrappedFunction(node);
+				if (fn === null) break;
+				const id = fn.type === "FunctionExpression" ? fn.id : null;
+				if (id !== null) out.push({
+					name: id.name,
+					fn,
+					regionStart
+				});
+				else out.push({
+					name: "default",
+					anonymous: true,
+					fn,
+					regionStart
+				});
+			}
+		}
+	}
+	return out;
+}
+/**
+* Top-level components (PascalCase, or an anonymous default export, which
+* route files commonly are) and custom hooks (`use*`) that may hold a hook.
+*/
+function candidates(program) {
+	return topLevelFunctions(program).filter(({ name, fn, anonymous }) => (anonymous === true || isComponentName(name) || isHookName(name)) && fn.async !== true && fn.generator !== true);
+}
+/** Records which watched names a binding pattern declares in `scope`. */
+function declare(pattern, scope, watched) {
+	if (pattern === null) return;
+	switch (pattern.type) {
+		case "Identifier":
+			if (watched.has(pattern.name)) (scope.shadowed ??= /* @__PURE__ */ new Set()).add(pattern.name);
+			return;
+		case "ObjectPattern":
+			for (const property of pattern.properties) declare(property.type === "RestElement" ? property.argument : property.value, scope, watched);
+			return;
+		case "ArrayPattern":
+			for (const element of pattern.elements) declare(element, scope, watched);
+			return;
+		case "AssignmentPattern":
+			declare(pattern.left, scope, watched);
+			return;
+		case "RestElement":
+			declare(pattern.argument, scope, watched);
+			return;
+		case "TSParameterProperty":
+			declare(pattern.parameter, scope, watched);
+			return;
+	}
+}
+/** `onClick`, `onChange`…: an event handler prop. */
+function isHandlerName(name) {
+	if (name === null || name.length < 3 || !name.startsWith("on")) return false;
+	const c = name.charCodeAt(2);
+	return c >= 65 && c <= 90;
+}
+/** The name of the property a member callee reads, or null. */
+function memberName(node) {
+	return node.type === "MemberExpression" ? keyName(node.property, node.computed === true) : null;
+}
+/** What a call to `callee` is to the hook pass: a locale call, or null. */
+function classify(call, context) {
+	const callee = unwrap(call.callee);
+	if (callee.type === "Identifier") {
+		const name = callee.name;
+		if (context.tNames.has(name)) return {
+			kind: "t",
+			call,
+			callee,
+			root: name
+		};
+		if (context.trackNames.has(name)) return {
+			kind: "track",
+			call,
+			callee,
+			root: name
+		};
+		return null;
+	}
+	const method = memberName(callee);
+	if (method === null || FUNCTION_METHODS.has(method)) return null;
+	const object = unwrap(callee.object);
+	if (object.type === "Identifier") {
+		const name = object.name;
+		if (context.namespaces.has(name)) {
+			if (method === "t") return {
+				kind: "t",
+				call,
+				callee,
+				root: name
+			};
+			if (NAMESPACE_TRACKED.has(method)) return {
+				kind: "track",
+				call,
+				callee,
+				root: name
+			};
+			return null;
+		}
+		if (context.trackNames.has(name)) return {
+			kind: "track",
+			call,
+			callee,
+			root: name
+		};
+		return null;
+	}
+	if (memberName(object) === "fmt") {
+		const owner = unwrap(object.object);
+		if (owner.type === "Identifier" && context.namespaces.has(owner.name)) return {
+			kind: "track",
+			call,
+			callee,
+			root: owner.name
+		};
+	}
+	return null;
+}
+/** True when `node` calls a hook (`useX(…)`, `React.useX(…)`), not counting the injected one. */
+function isHookCall(node, context) {
+	const callee = unwrap(node.callee);
+	if (callee.type === "Identifier") {
+		const name = callee.name;
+		return name !== context.useTLocal && isHookName(name);
+	}
+	const name = memberName(callee);
+	return name !== null && isHookName(name);
+}
+/** Walks every child node of `node` (types excluded). */
+function visitChildren(node, scope, analysis, context) {
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end" || TYPE_KEYS$1.has(key)) continue;
+		const value = node[key];
+		if (value === null || typeof value !== "object") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (item !== null && typeof item.type === "string") visit(item, scope, analysis, context);
+		} else if (typeof value.type === "string") visit(value, scope, analysis, context);
+	}
+}
+/** A nested function: its own scope, whose calls run during render unless shadowed. */
+function visitNested(fn, scope, analysis, context) {
+	const inner = {
+		calls: [],
+		shadowed: null,
+		children: []
+	};
+	scope.children.push(inner);
+	if (fn.type === "FunctionExpression") declare(fn.id, inner, context.watched);
+	for (const param of fn.params) {
+		declare(param, inner, context.watched);
+		visit(param, inner, analysis, context);
+	}
+	const body = fn.body;
+	if (body !== null) visit(body, inner, analysis, context);
+}
+/**
+* Walks what runs while the function renders: its own body and the nested
+* functions it may call during render. Classes are skipped, and so are
+* functions handed to hooks and inline `on*` handlers, which run after
+* render and keep the global `t` (see the module comment).
+*/
+function visit(node, scope, analysis, context) {
+	switch (node.type) {
+		case "FunctionDeclaration":
+			declare(node.id, scope, context.watched);
+			visitNested(node, scope, analysis, context);
+			return;
+		case "FunctionExpression":
+		case "ArrowFunctionExpression":
+			visitNested(node, scope, analysis, context);
+			return;
+		case "ClassDeclaration":
+			declare(node.id, scope, context.watched);
+			return;
+		case "ClassExpression": return;
+		case "JSXElement":
+		case "JSXFragment":
+			analysis.jsx = true;
+			break;
+		case "JSXAttribute": {
+			const name = node.name;
+			const value = node.value;
+			if (name.type === "JSXIdentifier" && isHandlerName(name.name) && value?.type === "JSXExpressionContainer" && isFunction$1(unwrap(value.expression))) return;
+			break;
+		}
+		case "Property":
+			if (isHandlerName(keyName(node.key, node.computed === true)) && isFunction$1(unwrap(node.value))) return;
+			break;
+		case "VariableDeclarator":
+			declare(node.id, scope, context.watched);
+			break;
+		case "CatchClause":
+			declare(node.param, scope, context.watched);
+			break;
+		case "CallExpression": {
+			const found = classify(node, context);
+			if (found !== null) scope.calls.push(found);
+			const callee = unwrap(node.callee);
+			if (callee.type === "Identifier" && context.factories.has(callee.name)) analysis.jsx = true;
+			else if (JSX_FACTORIES.has(memberName(callee) ?? "")) {
+				const object = unwrap(callee.object);
+				if (object.type === "Identifier" && context.reactNamespaces.has(object.name)) analysis.jsx = true;
+			}
+			if (isHookCall(node, context)) {
+				if (scope === analysis.root) analysis.hooks = true;
+				visit(node.callee, scope, analysis, context);
+				for (const argument of node.arguments) if (!isFunction$1(unwrap(argument))) visit(argument, scope, analysis, context);
+				return;
+			}
+			break;
+		}
+	}
+	visitChildren(node, scope, analysis, context);
+}
+/** The calls of `scope` and its nested functions that still reach the imports. */
+function liveCalls(scope, inherited, out) {
+	let blocked = inherited;
+	if (scope.shadowed !== null) blocked = inherited === null ? scope.shadowed : /* @__PURE__ */ new Set([...inherited, ...scope.shadowed]);
+	for (const call of scope.calls) if (blocked === null || !blocked.has(call.root)) out.push(call);
+	for (const child of scope.children) liveCalls(child, blocked, out);
+	return out;
+}
+/**
+* Names the module calls as plain functions (`Row()`, `Row.call(…)`,
+* `rows.map(Row)`), anywhere. A PascalCase function used that way is not
+* rendered as an element, so a hook in it would run conditionally or a
+* variable number of times (S13's `{cond && Row()}`).
+*/
+function plainlyCalled(program) {
+	const names = /* @__PURE__ */ new Set();
+	const stack = [program];
+	for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+		if (node.type === "CallExpression") {
+			const callee = unwrap(node.callee);
+			if (callee.type === "Identifier") names.add(callee.name);
+			else if (callee.type === "MemberExpression") {
+				const method = keyName(callee.property, callee.computed === true);
+				if (method !== null && PLAIN_CALLERS.has(method)) {
+					const object = unwrap(callee.object);
+					if ((method === "call" || method === "apply") && object.type === "Identifier") names.add(object.name);
+					for (const argument of node.arguments) {
+						const value = unwrap(argument);
+						if (value.type === "Identifier") names.add(value.name);
+					}
+				}
+			}
+		}
+		for (const key in node) {
+			if (key === "type" || key === "start" || key === "end" || TYPE_KEYS$1.has(key)) continue;
+			const value = node[key];
+			if (value === null || typeof value !== "object") continue;
+			if (Array.isArray(value)) {
+				for (const item of value) if (item !== null && typeof item.type === "string") stack.push(item);
+			} else if (typeof value.type === "string") stack.push(value);
+		}
+	}
+	return names;
+}
+const NONE = /* @__PURE__ */ new Set();
+function moduleContext(imports, options, glue) {
+	const { tNames, trackNames = NONE, namespaces = NONE } = options;
+	const context = {
+		tNames,
+		trackNames,
+		namespaces,
+		watched: /* @__PURE__ */ new Set([
+			...tNames,
+			...trackNames,
+			...namespaces
+		]),
+		useTLocal: null,
+		factories: /* @__PURE__ */ new Set(),
+		reactNamespaces: /* @__PURE__ */ new Set()
+	};
+	for (const record of imports) if (record.specifier === glue) {
+		for (const binding of record.bindings) if (binding.imported === USE_T) context.useTLocal = binding.local;
+	} else if (JSX_MODULES.has(record.specifier)) {
+		for (const { local, imported } of record.bindings) if (imported === "default" || imported === "*") context.reactNamespaces.add(local);
+		else if (JSX_FACTORIES.has(imported)) context.factories.add(local);
+	}
+	return context;
+}
+/**
+* Where a concise arrow body's expression (or its opening parenthesis)
+* starts: the first significant character after `=>`. -1 when no `=>` is
+* found before the body, which a parsed arrow never allows.
+*/
+function conciseBodyHead(code, fn) {
+	const body = fn.body;
+	let from = fn.start;
+	const params = fn.params;
+	if (params.length > 0) from = params[params.length - 1].end;
+	for (const key of ["typeParameters", "returnType"]) {
+		const typed = fn[key];
+		if (typed !== null && typed !== void 0 && typed.end > from) from = typed.end;
+	}
+	let at = skipTrivia(code, from, body.start);
+	while (at < body.start && !code.startsWith("=>", at)) at = skipTrivia(code, at + 1, body.start);
+	if (at >= body.start) return -1;
+	return skipTrivia(code, at + 2, body.start);
+}
+/** `const <local> = <useT>()` as the first statement after the directives: an earlier pass's hook. */
+function existingHookLocal(statements, useTLocal) {
+	if (useTLocal === null) return null;
+	const first = statements[directives(statements).length];
+	if (first?.type !== "VariableDeclaration") return null;
+	const declarations = first.declarations;
+	if (declarations.length !== 1) return null;
+	const declarator = declarations[0];
+	const id = declarator.id;
+	const init = declarator.init;
+	if (id.type !== "Identifier" || init === null) return null;
+	const call = unwrap(init);
+	if (call.type !== "CallExpression" || call.arguments.length !== 0) return null;
+	const callee = unwrap(call.callee);
+	return callee.type === "Identifier" && callee.name === useTLocal ? id.name : null;
+}
+/**
+* Injects the hook into every top-level component (PascalCase, or an
+* anonymous default export) or custom hook (`use*`) that reads the locale
+* while it renders and renders JSX or calls hooks: `const __t = useVi18nT();`
+* becomes its first statement (after directives; concise arrow bodies become
+* blocks), its `t` calls become `__t(…)`, and its `rich`/`fmt` calls
+* `rich.call(__t, …)`. That covers calls in nested functions that run during
+* render, unless the nested function shadows the name; functions passed to
+* hooks and inline `on*` handlers keep the global `t`. Class components,
+* async and generator functions are left alone, as are functions opted out
+* with a `/* vi18n-no-hook *\/` comment before their body or a
+* `"use no memo"` directive (function or module), and PascalCase functions
+* that call no hook but are called as plain functions in this module. Adds
+* `import { __vi18nUseT as useVi18nT } from "virtual:vi18n/glue/<framework>"`
+* once. Idempotent: hooked calls are no longer direct calls of the imports.
+* Returns true when anything was edited.
+*/
+function injectHooks(parsed, sink, options) {
+	if (options.tNames.size === 0 && (options.trackNames?.size ?? 0) === 0 && (options.namespaces?.size ?? 0) === 0) return false;
+	const program = parsed.program;
+	if (hasNoMemo(program.body)) return false;
+	const found = candidates(program);
+	if (found.length === 0) return false;
+	const code = parsed.code;
+	const glue = GLUE + options.framework;
+	const context = moduleContext(listImports(parsed), options, glue);
+	const anyOptOut = code.includes(NO_HOOK_COMMENT);
+	let plain = null;
+	let useTLocal = context.useTLocal;
+	let hookLocal = null;
+	let edited = false;
+	for (const { name, anonymous, fn, regionStart } of found) {
+		const body = fn.body;
+		const block = body.type === "BlockStatement";
+		const statements = block ? body.body : [];
+		if (block && hasNoMemo(statements)) continue;
+		const root = {
+			calls: [],
+			shadowed: null,
+			children: []
+		};
+		const analysis = {
+			root,
+			jsx: false,
+			hooks: false
+		};
+		for (const param of fn.params) declare(param, root, context.watched);
+		visit(body, root, analysis, context);
+		const calls = liveCalls(root, null, []);
+		if (calls.length === 0 || !(analysis.jsx || analysis.hooks)) continue;
+		if (anonymous !== true && isComponentName(name) && !analysis.hooks) {
+			plain ??= plainlyCalled(program);
+			if (plain.has(name)) continue;
+		}
+		const prologue = block ? directives(statements) : [];
+		const firstStatement = statements[prologue.length];
+		const bodyHead = block ? firstStatement?.start ?? body.end - 1 : body.start;
+		if (anyOptOut && optedOut(code, regionStart, bodyHead)) continue;
+		let local = block ? existingHookLocal(statements, useTLocal) : null;
+		if (local === null) {
+			const head = block ? -1 : conciseBodyHead(code, fn);
+			if (!block && head === -1) continue;
+			useTLocal ??= freeName(code, USE_T_LOCAL);
+			hookLocal ??= freeName(code, HOOK_LOCAL);
+			local = hookLocal;
+			const declaration = `const ${local} = ${useTLocal}();`;
+			if (!block) {
+				sink.appendLeft(head, `{ ${declaration} return `);
+				sink.appendLeft(fn.end, "; }");
+			} else {
+				const last = prologue[prologue.length - 1];
+				if (last === void 0) sink.appendLeft(body.start + 1, ` ${declaration}`);
+				else {
+					const semi = code.charCodeAt(last.end - 1) === 59 ? "" : ";";
+					sink.appendLeft(last.end, `${semi} ${declaration}`);
+				}
+			}
+		}
+		for (const { kind, call, callee } of calls) {
+			if (kind === "t") {
+				sink.overwrite(callee.start, callee.end, local);
+				continue;
+			}
+			sink.appendLeft(callee.end, ".call");
+			const first = call.arguments[0];
+			if (first === void 0) sink.appendLeft(call.end - 1, local);
+			else sink.appendLeft(first.start, `${local}, `);
+		}
+		edited = true;
+	}
+	if (edited && context.useTLocal === null) {
+		const statement = `import { ${USE_T} as ${useTLocal} } from ${JSON.stringify(glue)};`;
+		const prologue = directives(program.body);
+		const last = prologue[prologue.length - 1];
+		if (last !== void 0) {
+			const semi = code.charCodeAt(last.end - 1) === 59 ? "" : ";";
+			sink.appendLeft(last.end, `${semi}\n${statement}`);
+		} else if (program.hashbang != null) sink.appendLeft(program.hashbang.end, `\n${statement}`);
+		else sink.prepend(`${statement}\n`);
+	}
+	return edited;
+}
+//#endregion
+//#region src/core/extract/captured.ts
+/** Callee kinds whose result is translated text (not `msg`, which declares a message). */
+const TRANSLATING = /* @__PURE__ */ new Set([
+	"t",
+	"rich",
+	"richHtml",
+	"richParts",
+	"alias",
+	"global",
+	"translator"
+]);
+const FIX = {
+	svelte: "call t() in the markup or derive it with $derived(t(…))",
+	vue: "call t() in the template or use computed(() => t(…))",
+	solid: "call t() in JSX, or make it a function (() => t(…)) or createMemo(() => t(…))",
+	react: "call t() during render instead of keeping its result",
+	preact: "call t() during render instead of keeping its result",
+	astro: ""
+};
+/**
+* React/Preact hooks whose arguments are kept from the first render: the
+* argument positions, and whether a function there is called once (a lazy
+* initialiser) or stored as it is (`useRef(fn)`, `useSignal(fn)`).
+*/
+const ONCE_HOOKS = /* @__PURE__ */ new Map([
+	["useState", [[0, "call"]]],
+	["useRef", [[0, "store"]]],
+	["useReducer", [[1, "store"], [2, "call"]]],
+	["useSignal", [[0, "store"]]]
+]);
+/** Vue's function-form components: the first argument is `setup`. */
+const VUE_DEFINE = /* @__PURE__ */ new Set(["defineComponent", "defineVaporComponent"]);
+/** Vue options whose function runs once per instance, next to these keys that mark a component. */
+const VUE_ONCE = /* @__PURE__ */ new Set(["setup", "data"]);
+const VUE_COMPONENT_KEYS = /* @__PURE__ */ new Set([
+	"setup",
+	"render",
+	"template",
+	"props",
+	"computed",
+	"methods",
+	"components",
+	"watch",
+	"emits",
+	"name",
+	"__name"
+]);
+/** Keys that hold only TypeScript types; nothing under them runs. */
+const TYPE_KEYS = /* @__PURE__ */ new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"typeArguments",
+	"superTypeArguments",
+	"returnType",
+	"implements"
+]);
+const RETURNED = "the returned value";
+function isFunction(node) {
+	return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration";
+}
+/** Pushes the children of `node` that are nodes (types excluded). */
+function children(node, into) {
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end" || TYPE_KEYS.has(key)) continue;
+		const value = node[key];
+		if (value === null || typeof value !== "object") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (item !== null && typeof item.type === "string") into.push(item);
+		} else if (typeof value.type === "string") into.push(value);
+	}
+}
+var Finder = class {
+	/** Reported calls by start offset, so diagnostics come out in source order whatever the walk order. */
+	found = [];
+	/** Call start → index into `scan.calls`, for translating calls only. */
+	targets = /* @__PURE__ */ new Map();
+	reported = /* @__PURE__ */ new Set();
+	code;
+	scan;
+	fix;
+	/** What a `return` inside a once-running function stores, as named in messages. */
+	returned = RETURNED;
+	/** Roots (`__t`, a translator object) of calls the current walk treats as live. */
+	live = null;
+	markers;
+	ranges;
+	constructor(parsed, scan, framework, ranges) {
+		this.code = parsed.code;
+		this.scan = scan;
+		this.fix = FIX[framework];
+		this.markers = markersOf(parsed);
+		this.ranges = ranges;
+		for (let i = 0; i < scan.calls.length; i++) {
+			const call = scan.calls[i];
+			if (TRANSLATING.has(call.kind) && call.callStart !== void 0) this.targets.set(call.callStart, i);
+		}
+	}
+	get empty() {
+		return this.targets.size === 0;
+	}
+	/** The `scan.calls` index of a translating call node, or -1. */
+	target(node) {
+		if (node.type !== "CallExpression") return -1;
+		const index = this.targets.get(node.start);
+		if (index === void 0) return -1;
+		const call = this.scan.calls[index];
+		return call.callEnd === void 0 || call.callEnd === node.end ? index : -1;
+	}
+	report(node, subject) {
+		const index = this.target(node);
+		if (index === -1 || this.reported.has(index)) return;
+		if (this.live !== null && this.live.has(rootName(node))) return;
+		if (this.markers.ignored.length > 0 && isIgnored(this.markers, node.start)) return;
+		this.reported.add(index);
+		const occurrence = this.scan.occurrences[this.scan.calls[index].occurrence];
+		const diagnostic = {
+			code: "extract-captured-value",
+			severity: "warning",
+			message: `${subject} captures a translation once and keeps the old locale's text after setLocale(); ${this.fix}`
+		};
+		if (occurrence !== void 0) {
+			diagnostic.file = occurrence.file;
+			if (occurrence.line > 0) {
+				diagnostic.line = occurrence.line;
+				diagnostic.column = occurrence.column;
+			}
+			diagnostic.id = occurrence.id;
+		}
+		if (this.ranges) diagnostic.range = [node.start, node.end];
+		this.found.push([node.start, diagnostic]);
+	}
+	get diagnostics() {
+		return this.found.sort((a, b) => a[0] - b[0]).map((entry) => entry[1]);
+	}
+	/**
+	* A hook argument kept from the first render. A function is called once
+	* (`returned` names what it returns) or stored and called later; any other
+	* value is stored as computed, and functions inside it run later.
+	*/
+	kept(argument, function_, subject) {
+		const value = unwrap(argument);
+		if (!isFunction(value)) this.once(value, subject);
+		else if (function_ === "call") this.onceFunction(value, subject);
+	}
+	/**
+	* A `useMemo` callback: runs on the first render and again only when its
+	* dependencies change, so its stored result is captured unless it reads
+	* through a translator in `live`.
+	*/
+	memo(callback, subject, live) {
+		const value = unwrap(callback);
+		if (!isFunction(value)) return;
+		this.live = live;
+		try {
+			this.onceFunction(value, subject);
+		} finally {
+			this.live = null;
+		}
+	}
+	/** How a stored value is named in the message. */
+	subject(target) {
+		const node = unwrap(target);
+		if (node.type === "Identifier") return `\`${node.name}\``;
+		if (node.type === "MemberExpression" && node.end - node.start <= 40) return `\`${this.code.slice(node.start, node.end).replace(/\s+/g, "")}\``;
+		return "this declaration";
+	}
+	/** A function that runs once: its body, with a concise body as its returned value. */
+	onceFunction(fn, returned = RETURNED) {
+		const body = fn.body;
+		if (body === null) return;
+		const outer = this.returned;
+		this.returned = returned;
+		try {
+			if (body.type === "BlockStatement") this.once(body, null);
+			else this.once(body, returned);
+		} finally {
+			this.returned = outer;
+		}
+	}
+	/**
+	* Walks code that runs when the enclosing once-running function runs.
+	* `subject` is non-null inside a value that is stored.
+	*/
+	once(node, subject) {
+		switch (node.type) {
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+			case "ClassDeclaration":
+			case "ClassExpression":
+			case "JSXElement":
+			case "JSXFragment": return;
+			case "CallExpression": {
+				const callee = unwrap(node.callee);
+				if (isDerived(callee)) return;
+				if (subject !== null) this.report(node, subject);
+				if (callee.type === "FunctionExpression" || callee.type === "ArrowFunctionExpression") this.onceFunction(callee);
+				else this.once(callee, subject);
+				for (const argument of node.arguments) this.once(argument, subject);
+				return;
+			}
+			case "VariableDeclarator": {
+				const init = node.init;
+				const stored = this.subject(node.id);
+				this.once(node.id, stored);
+				if (init !== null) this.once(init, stored);
+				return;
+			}
+			case "AssignmentExpression":
+				this.once(node.left, subject);
+				this.once(node.right, this.subject(node.left));
+				return;
+			case "ReturnStatement":
+				if (node.argument !== null) this.once(node.argument, this.returned);
+				return;
+			default: {
+				const list = [];
+				children(node, list);
+				for (const child of list) this.once(child, subject);
+			}
+		}
+	}
+};
+/** Svelte's `$derived(…)` and `$derived.by(…)`, as written in a component's source. */
+function isDerived(callee) {
+	if (callee.type === "Identifier") return callee.name === "$derived";
+	return callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "$derived";
+}
+/** Svelte 5 client components: top-level `function C($$anchor, …)`. */
+function svelteComponents(program) {
+	const out = [];
+	for (const statement of program.body) {
+		let node = statement;
+		if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") node = node.declaration ?? node;
+		if (node.type !== "FunctionDeclaration") continue;
+		const first = node.params[0];
+		if (first?.type === "Identifier" && first.name === "$$anchor") out.push(node);
+	}
+	return out;
+}
+/**
+* Vue `setup()`/`data()` functions of objects that look like component
+* options, and the setup function of the function form
+* `defineComponent((props) => { … })` (`define` holds the imported locals of
+* `defineComponent`/`defineVaporComponent`; `Vue.defineComponent` counts too).
+*/
+function vueOnceFunctions(program, define) {
+	const out = [];
+	const stack = [program];
+	for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+		if (node.type === "CallExpression") {
+			const callee = unwrap(node.callee);
+			const defines = callee.type === "Identifier" ? define.has(callee.name) : callee.type === "MemberExpression" && VUE_DEFINE.has(keyName(callee.property, callee.computed === true) ?? "");
+			const first = node.arguments[0];
+			const setup = first === void 0 ? null : unwrap(first);
+			if (defines && setup !== null && isFunction(setup)) out.push(setup);
+		} else if (node.type === "ObjectExpression") {
+			let component = false;
+			const found = [];
+			for (const property of node.properties) {
+				if (property.type !== "Property") continue;
+				const name = keyName(property.key, property.computed === true);
+				if (name === null) continue;
+				if (VUE_COMPONENT_KEYS.has(name)) component = true;
+				const value = unwrap(property.value);
+				if (VUE_ONCE.has(name) && isFunction(value)) {
+					if (name === "setup") component = true;
+					found.push(value);
+				}
+			}
+			if (component) out.push(...found);
+		}
+		children(node, stack);
+	}
+	return out;
+}
+/** The name a callee calls (`useMemo`, `React.useMemo`), or null. */
+function calleeName(call) {
+	const callee = unwrap(call.callee);
+	if (callee.type === "Identifier") return callee.name;
+	if (callee.type === "MemberExpression") return keyName(callee.property, callee.computed === true);
+	return null;
+}
+/**
+* Locals that hold the locale: `const locale = getLocale()` with `getLocale`
+* imported. A `useMemo` keyed on one recomputes on a switch.
+*/
+function localeLocals(program, getLocale) {
+	const out = /* @__PURE__ */ new Set();
+	if (getLocale.size === 0) return out;
+	const stack = [program];
+	for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+		children(node, stack);
+		if (node.type !== "VariableDeclarator") continue;
+		const id = node.id;
+		const init = node.init === null ? null : unwrap(node.init);
+		if (id.type === "Identifier" && init?.type === "CallExpression" && isLocaleCall(init, getLocale)) out.add(id.name);
+	}
+	return out;
+}
+function isLocaleCall(call, getLocale) {
+	const callee = unwrap(call.callee);
+	return callee.type === "Identifier" && getLocale.has(callee.name);
+}
+/**
+* React/Preact hook initialisers that run once. A `useMemo` callback is
+* captured unless its dependencies name the call's translator (the hook
+* local `__t`, or a translator object), which changes per locale, or the
+* locale itself (`getLocale()`, or a local holding it); an imported `t`
+* never changes identity, so listing it does not help.
+*/
+function reactHooks(program, finder, imports) {
+	const imported = /* @__PURE__ */ new Set();
+	const getLocale = /* @__PURE__ */ new Set();
+	for (const record of imports) for (const binding of record.bindings) {
+		imported.add(binding.local);
+		if (binding.imported === "getLocale") getLocale.add(binding.local);
+	}
+	let locales = null;
+	const stack = [program];
+	for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+		children(node, stack);
+		if (node.type !== "CallExpression") continue;
+		const name = calleeName(node);
+		if (name === null) continue;
+		const args = node.arguments;
+		if (name === "useMemo") {
+			const deps = args[1] === void 0 ? null : unwrap(args[1]);
+			if (deps === null || deps.type !== "ArrayExpression") continue;
+			locales ??= localeLocals(program, getLocale);
+			const live = /* @__PURE__ */ new Set();
+			let keyedOnLocale = false;
+			for (const element of deps.elements) {
+				const value = element === null ? null : unwrap(element);
+				if (value?.type === "Identifier") {
+					const dep = value.name;
+					if (locales.has(dep)) keyedOnLocale = true;
+					else if (!imported.has(dep)) live.add(dep);
+				} else if (value?.type === "CallExpression" && isLocaleCall(value, getLocale)) keyedOnLocale = true;
+			}
+			if (!keyedOnLocale && args[0] !== void 0) finder.memo(args[0], "a useMemo() without the translator or the locale in its dependencies", live);
+			continue;
+		}
+		const positions = ONCE_HOOKS.get(name);
+		if (positions === void 0) continue;
+		for (const [position, function_] of positions) {
+			const argument = args[position];
+			if (argument !== void 0 && argument.type !== "SpreadElement") finder.kept(argument, function_, `the initial value of ${name}()`);
+		}
+	}
+}
+/** The identifier a callee starts from (`__t` in `__t(…)`, `tr` in `tr.t(…)`), or "". */
+function rootName(call) {
+	let node = unwrap(call.callee);
+	for (;;) {
+		if (node.type === "Identifier") return node.name;
+		if (node.type === "MemberExpression") node = unwrap(node.object);
+		else if (node.type === "SequenceExpression") {
+			const expressions = node.expressions;
+			node = unwrap(expressions[expressions.length - 1]);
+		} else return "";
+	}
+}
+/**
+* Warnings (`extract-captured-value`) for translations that `framework`'s
+* components compute once and keep, so an in-place locale switch leaves them
+* in the old locale. Positions are the occurrences' (the message literal);
+* `id` names the message. No framework, or Astro, finds nothing. Calls under
+* `vi18n-ignore` are not reported. The `/lint` rule passes `topLevel` for a
+* Vue or Svelte script as written, and `ranges` to report at the call.
+*/
+function findCapturedValues(parsed, scan, framework, options = {}) {
+	if (framework === null || framework === "astro") return [];
+	const finder = new Finder(parsed, scan, framework, options.ranges === true);
+	if (finder.empty) return [];
+	const program = parsed.program;
+	if (options.topLevel === true) finder.onceFunction({
+		type: "FunctionExpression",
+		start: program.start,
+		end: program.end,
+		body: {
+			type: "BlockStatement",
+			start: program.start,
+			end: program.end,
+			body: program.body
+		}
+	});
+	switch (framework) {
+		case "svelte":
+			for (const fn of svelteComponents(program)) finder.onceFunction(fn);
+			break;
+		case "vue": {
+			const define = /* @__PURE__ */ new Set();
+			for (const record of listImports(parsed)) for (const binding of record.bindings) if (VUE_DEFINE.has(binding.imported)) define.add(binding.local);
+			for (const fn of vueOnceFunctions(program, define)) finder.onceFunction(fn);
+			break;
+		}
+		case "solid":
+			for (const { name, fn } of topLevelFunctions(program)) if (isComponentName(name)) finder.onceFunction(fn);
+			break;
+		default: reactHooks(program, finder, listImports(parsed));
+	}
+	return finder.diagnostics;
+}
+//#endregion
+export { injectHooks as n, findCapturedValues as t };