@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/sources-D19czDSA.js

@@ -0,0 +1,2242 @@
+import { a as diagnosticError, o as isDiagnosticError, r as DEFAULT_IMPORT_SOURCES } from "./types-D3QGM8XO.js";
+import { n as validateSource, o as isValidManualId } from "./validate-BxpupdAf.js";
+import { createRequire } from "node:module";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+//#region src/core/extract/imports.ts
+const memo = /* @__PURE__ */ new WeakMap();
+function exportedName(node) {
+	return node.type === "Literal" ? String(node.value) : node.name;
+}
+/**
+* Every value import of the module in source order, with its bindings.
+* Type-only declarations and specifiers (`import type`, `import { type T }`)
+* are left out: they bind nothing at runtime. A side-effect import has no
+* bindings. The returned array is shared between calls and must not be mutated.
+*/
+function listImports(parsed) {
+	const known = memo.get(parsed);
+	if (known !== void 0) return known;
+	const records = [];
+	for (const statement of parsed.program.body) {
+		if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+		const bindings = [];
+		for (const specifier of statement.specifiers) {
+			if (specifier.importKind === "type") continue;
+			const local = specifier.local.name;
+			switch (specifier.type) {
+				case "ImportDefaultSpecifier":
+					bindings.push({
+						local,
+						imported: "default"
+					});
+					break;
+				case "ImportNamespaceSpecifier":
+					bindings.push({
+						local,
+						imported: "*"
+					});
+					break;
+				default: bindings.push({
+					local,
+					imported: exportedName(specifier.imported)
+				});
+			}
+		}
+		if (bindings.length === 0 && statement.specifiers.length > 0) continue;
+		records.push({
+			specifier: String(statement.source.value),
+			start: statement.start,
+			end: statement.end,
+			bindings
+		});
+	}
+	memo.set(parsed, records);
+	return records;
+}
+//#endregion
+//#region src/core/extract/locate.ts
+/**
+* Positions in original files (INTERNALS §2.5.1). Post-compile offsets of
+* `.vue`/`.svelte`/`.astro`/`.mdx` output mean nothing in the file the user
+* edits, and composing source maps per occurrence costs too much, so a
+* literal's position is recovered by searching the original text (§6 D14).
+*/
+let cachedText = null;
+let cachedStarts = [];
+function lineStarts(text) {
+	if (text === cachedText) return cachedStarts;
+	const starts = [0];
+	for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1)) starts.push(i + 1);
+	cachedText = text;
+	cachedStarts = starts;
+	return starts;
+}
+/**
+* 1-based line and column of a UTF-16 offset. Lines end at `\n` (a `\r`
+* before it belongs to the line it ends); columns count UTF-16 code units, as
+* the parser's offsets do.
+*/
+function lineColumn(text, offset) {
+	const starts = lineStarts(text);
+	let low = 0;
+	let high = starts.length - 1;
+	while (low < high) {
+		const mid = low + high + 1 >>> 1;
+		if (starts[mid] <= offset) low = mid;
+		else high = mid - 1;
+	}
+	return {
+		line: low + 1,
+		column: offset - starts[low] + 1
+	};
+}
+/**
+* The body of a JS string literal for `value` between `quote`s, escaped as
+* people and compilers write it. Template literals hold newlines and tabs raw
+* unless `escapeWhitespace`, the way `\`a\nb\`` is typed.
+*/
+function quoted(value, quote, escapeWhitespace = quote === "'") {
+	let out = "";
+	for (let i = 0; i < value.length; i++) {
+		const ch = value[i];
+		switch (ch) {
+			case "\\":
+				out += "\\\\";
+				break;
+			case quote:
+				out += "\\" + quote;
+				break;
+			case "$":
+				out += quote === "`" && value[i + 1] === "{" ? "\\$" : "$";
+				break;
+			case "\n":
+				out += escapeWhitespace ? "\\n" : "\n";
+				break;
+			case "\r":
+				out += "\\r";
+				break;
+			case "	":
+				out += escapeWhitespace ? "\\t" : "	";
+				break;
+			default: out += ch;
+		}
+	}
+	return quote + out + quote;
+}
+const QUOTES = /* @__PURE__ */ new Set([
+	"\"",
+	"'",
+	"`"
+]);
+function earliest(text, needles, from) {
+	let best = -1;
+	for (const needle of needles) {
+		const at = text.indexOf(needle, from);
+		if (at !== -1 && (best === -1 || at < best)) best = at;
+	}
+	return best;
+}
+/**
+* Finds `literal` (a JS string value) in an original file at or after offset
+* `from`. Quoted spellings — JSON-escaped in double quotes, single quotes or
+* backticks — win over a bare match, which may sit in a comment or inside a
+* longer word; the bare value (raw, or JSON-escaped without quotes) is the
+* fallback for files that never quote it. The position is the opening
+* quote's, like the parser's literal offsets. Pass `previous.offset + 1` to
+* find the next occurrence of the same literal.
+*/
+function locateLiteral(fileText, literal, from = 0) {
+	const json = JSON.stringify(literal);
+	const start = from < 0 ? 0 : from;
+	const template = quoted(literal, "`");
+	const needles = [
+		json,
+		quoted(literal, "'"),
+		template
+	];
+	if (/[\n\t]/.test(literal)) needles.push(quoted(literal, "`", true));
+	if (literal.includes("\n") && fileText.includes("\r\n")) needles.push(template.replaceAll("\n", "\r\n"));
+	if (/[\u2028\u2029]/.test(literal)) for (const needle of needles.slice()) needles.push(needle.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029"));
+	if (/[\u0080-\uffff]/.test(literal)) for (const needle of needles.slice()) for (const upper of [false, true]) needles.push(needle.replace(/[\u0080-\uffff]/g, (ch) => {
+		const hex = ch.charCodeAt(0).toString(16).padStart(4, "0");
+		return "\\u" + (upper ? hex.toUpperCase() : hex);
+	}));
+	let offset = earliest(fileText, needles, start);
+	if (offset === -1 && literal !== "" && (start === 0 || earliest(fileText, needles, 0) === -1)) {
+		offset = earliest(fileText, [literal, json.slice(1, -1)], start);
+		if (offset > 0 && QUOTES.has(fileText[offset - 1])) offset--;
+	}
+	if (offset === -1) return null;
+	return {
+		...lineColumn(fileText, offset),
+		offset
+	};
+}
+//#endregion
+//#region src/core/extract/sinks.ts
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"TSInstantiationExpression",
+	"ParenthesizedExpression"
+]);
+/** Strips parentheses and TypeScript-only wrappers, which change nothing at runtime. */
+function unwrap(node) {
+	let current = node;
+	while (WRAPPERS.has(current.type)) current = current.expression;
+	return current;
+}
+/** The name of a non-computed member/property key, or of a computed one written as a string literal. */
+function keyName(key, computed) {
+	if (!computed && (key.type === "Identifier" || key.type === "JSXIdentifier")) return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+	return null;
+}
+function propertyValue(objectNode, name) {
+	for (const property of objectNode.properties) if (property.type === "Property" && keyName(property.key, property.computed === true) === name) return unwrap(property.value);
+	return null;
+}
+/**
+* Calls `mark` with every expression that `node` inserts as HTML: Svelte
+* `$.html(…, () => X)`, Vue `innerHTML: X`, React
+* `dangerouslySetInnerHTML: { __html: X }` (compiled or as a JSX attribute),
+* Solid's `innerHTML={X}`, Astro `$$unescapeHTML(X)` and `x.innerHTML = X`.
+* Only direct flows count: a value built from `X` is not `X`.
+*/
+function markHtmlSinks(node, mark) {
+	switch (node.type) {
+		case "Property": {
+			if (node.kind !== "init" || node.method === true) return;
+			const name = keyName(node.key, node.computed === true);
+			if (name === "innerHTML") mark(unwrap(node.value));
+			else if (name === "dangerouslySetInnerHTML") {
+				const value = unwrap(node.value);
+				if (value.type === "ObjectExpression") {
+					const html = propertyValue(value, "__html");
+					if (html !== null) mark(html);
+				}
+			}
+			return;
+		}
+		case "JSXAttribute": {
+			const value = node.value;
+			if (value?.type !== "JSXExpressionContainer") return;
+			const name = keyName(node.name, false);
+			const expression = unwrap(value.expression);
+			if (name === "innerHTML") mark(expression);
+			else if (name === "dangerouslySetInnerHTML" && expression.type === "ObjectExpression") {
+				const html = propertyValue(expression, "__html");
+				if (html !== null) mark(html);
+			}
+			return;
+		}
+		case "AssignmentExpression": {
+			const left = node.left;
+			if ((node.operator === "=" || node.operator === "+=") && left.type === "MemberExpression" && keyName(left.property, left.computed === true) === "innerHTML") mark(unwrap(node.right));
+			return;
+		}
+		case "CallExpression": {
+			const callee = unwrap(node.callee);
+			const args = node.arguments;
+			if (callee.type === "Identifier" && callee.name === "$$unescapeHTML") {
+				if (args[0] !== void 0) mark(unwrap(args[0]));
+				return;
+			}
+			if (callee.type === "MemberExpression" && callee.computed !== true && callee.object.type === "Identifier" && callee.object.name === "$" && callee.property.name === "html") {
+				for (const arg of args) if (arg.type === "ArrowFunctionExpression" && arg.expression === true) mark(unwrap(arg.body));
+			}
+			return;
+		}
+	}
+}
+/** `extract-module-scope`; `severity` follows `strict.moduleScope`. */
+function moduleScopeDiagnostic(callee, severity, where) {
+	return {
+		code: "extract-module-scope",
+		severity,
+		message: `${callee}() runs at module scope, so its text freezes at import and has no request on the server; call it inside a function or component, or declare the message with msg()`,
+		...where
+	};
+}
+/** `extract-html-sink`: `t()` does not escape values, `richHtml()` does. */
+function htmlSinkDiagnostic(callee, id, where) {
+	return {
+		code: "extract-html-sink",
+		severity: "warning",
+		message: `${callee}() returns plain text with unescaped values but is inserted as HTML here; use richHtml(), which escapes values`,
+		id,
+		...where
+	};
+}
+/** `extract-wrapper-unused`: usually a wrapper export missing from `extraction.aliases`. */
+function wrapperUnusedDiagnostic(specifier, where) {
+	return {
+		code: "extract-wrapper-unused",
+		severity: "warning",
+		message: `This module imports from the wrapper ${JSON.stringify(specifier)} but makes no vi18n call; add the wrapper's translation functions to extraction.aliases`,
+		...where
+	};
+}
+//#endregion
+//#region src/core/extract/comments.ts
+const NONE = {
+	ignored: [],
+	contexts: []
+};
+/** Keys that are not children: positions, and the back links ESLint and oxlint add. */
+const NOT_CHILDREN = /* @__PURE__ */ new Set([
+	"type",
+	"start",
+	"end",
+	"range",
+	"loc",
+	"parent"
+]);
+const IGNORE = /^vi18n-ignore(?:\s|$)/;
+const CONTEXT = "vi18n-context:";
+function span(node) {
+	return node.range === void 0 ? {
+		start: node.start ?? 0,
+		end: node.end ?? 0
+	} : {
+		start: node.range[0],
+		end: node.range[1]
+	};
+}
+/** Whether `code` can hold a marker: the check before any comment is read. */
+function hasMarkers(code) {
+	return code.includes("vi18n-");
+}
+/** The marker a comment holds, or null. Block comments may use JSDoc's leading `*`. */
+function markerOf(comment) {
+	let text = comment.value;
+	if (comment.type === "Block") text = text.split("\n").map((line) => line.replace(/^\s*\*?/, "")).join("\n");
+	text = text.trimStart();
+	if (IGNORE.test(text)) return { note: null };
+	if (!text.startsWith(CONTEXT)) return null;
+	const note = text.slice(14).split("\n").map((line) => line.trim()).filter((line) => line !== "").join("\n");
+	return note === "" ? null : { note };
+}
+/** The child of `node` whose range holds `offset`, or null. */
+function childAt(node, offset) {
+	for (const key in node) {
+		if (NOT_CHILDREN.has(key)) continue;
+		const value = node[key];
+		if (value === null || typeof value !== "object") continue;
+		for (const item of Array.isArray(value) ? value : [value]) {
+			if (item === null || typeof item !== "object" || typeof item.type !== "string") continue;
+			const { start, end } = span(item);
+			if (start <= offset && offset < end) return item;
+		}
+	}
+	return null;
+}
+/**
+* The outermost node below `root` that starts at `offset` (null when the
+* offset is punctuation, such as a closing brace), and the innermost node
+* that holds it.
+*/
+function nodeAt(root, offset) {
+	let holder = root;
+	for (;;) {
+		const child = childAt(holder, offset);
+		if (child === null) return {
+			at: null,
+			holder
+		};
+		if (span(child).start === offset) return {
+			at: child,
+			holder: child
+		};
+		holder = child;
+	}
+}
+/** The first offset at or after `from` that is not whitespace or inside a comment. */
+function nextToken(code, from, comments) {
+	let at = from;
+	let next = 0;
+	for (;;) {
+		while (at < code.length && /\s/.test(code[at])) at++;
+		while (next < comments.length && comments[next].start < at) next++;
+		const comment = comments[next];
+		if (comment === void 0 || comment.start !== at) return at;
+		at = comment.end;
+	}
+}
+/** A comment after code on its line with nothing after it: it belongs to that line, not the next. */
+function trails(code, start, end) {
+	const lineStart = code.lastIndexOf("\n", start - 1) + 1;
+	if (code.slice(lineStart, start).trim() === "") return false;
+	const lineEnd = code.indexOf("\n", end);
+	return code.slice(end, lineEnd === -1 ? code.length : lineEnd).trim() === "";
+}
+/**
+* The ranges the marker comments among `comments` cover in `program` (an
+* ESTree `Program` of `code`). A marker that trails code on its line, or
+* that no node follows, covers nothing. `{/* vi18n-ignore *\/}` alone in a
+* JSX child covers the child after it.
+*/
+function findMarkers(code, program, comments) {
+	if (!hasMarkers(code)) return NONE;
+	const spans = comments.map(span).sort((a, b) => a.start - b.start);
+	const markers = {
+		ignored: [],
+		contexts: []
+	};
+	for (const comment of comments) {
+		const marker = markerOf(comment);
+		if (marker === null) continue;
+		const { start, end } = span(comment);
+		if (trails(code, start, end)) continue;
+		let found = nodeAt(program, nextToken(code, end, spans));
+		const container = found.holder;
+		if (found.at === null && container.type === "JSXExpressionContainer" && container.expression?.type === "JSXEmptyExpression") found = nodeAt(program, nextToken(code, span(container).end, spans));
+		if (found.at === null) continue;
+		const target = span(found.at);
+		if (marker.note === null) markers.ignored.push([target.start, target.end]);
+		else markers.contexts.push({
+			note: marker.note,
+			...target
+		});
+	}
+	return markers;
+}
+/** Whether `offset` lies in code a `vi18n-ignore` covers. */
+function isIgnored(markers, offset) {
+	for (const [start, end] of markers.ignored) if (start <= offset && offset < end) return true;
+	return false;
+}
+const cache = /* @__PURE__ */ new WeakMap();
+/** {@link findMarkers} of a parsed module, once per module (the scan and the captured-value pass share it). */
+function markersOf(parsed) {
+	if (parsed.comments === void 0 || !hasMarkers(parsed.code)) return NONE;
+	let markers = cache.get(parsed);
+	if (markers === void 0) {
+		markers = findMarkers(parsed.code, parsed.program, parsed.comments);
+		cache.set(parsed, markers);
+	}
+	return markers;
+}
+//#endregion
+//#region src/core/extract/zod.ts
+/**
+* The messages of the zod bridge (`vi18nZod()`, INTERNALS §6 D206). The
+* scanner treats a `vi18nZod()` call as a `msg()` of each, in this order, and
+* the transform passes them to the call, so they are extracted, translated
+* and split like any message written at the call. The runtime
+* (`src/runtime/zod.ts`) picks one by index: the order is the contract, and
+* `tests/runtime/zod.test.ts` renders every issue through both.
+*
+* Worded for the people filling a form, not for developers: zod's own texts
+* ("Too small: expected string to have >=3 characters") stay its fallback.
+*/
+const ZOD_MESSAGES = [
+	["Required", "Validation error: a required field is empty"],
+	["{expected, select, number {Must be a number} int {Must be a whole number} bigint {Must be a whole number} boolean {Must be true or false} date {Must be a date} string {Must be text} array {Must be a list} file {Must be a file} other {Invalid value}}", "Validation error: a value of the wrong type"],
+	["{count, plural, one {Must be at least # character} other {Must be at least # characters}}", "Validation error: a text is too short"],
+	["{count, plural, one {Must be at most # character} other {Must be at most # characters}}", "Validation error: a text is too long"],
+	["{count, plural, one {Must be exactly # character} other {Must be exactly # characters}}", "Validation error: a text must have this exact length"],
+	["{count, plural, one {Must have at least # item} other {Must have at least # items}}", "Validation error: a list has too few items"],
+	["{count, plural, one {Must have at most # item} other {Must have at most # items}}", "Validation error: a list has too many items"],
+	["{count, plural, one {Must have exactly # item} other {Must have exactly # items}}", "Validation error: a list must have this exact number of items"],
+	["{count, plural, one {Must be at least # byte} other {Must be at least # bytes}}", "Validation error: a file is too small"],
+	["{count, plural, one {Must be at most # byte} other {Must be at most # bytes}}", "Validation error: a file is too large"],
+	["{count, plural, one {Must be exactly # byte} other {Must be exactly # bytes}}", "Validation error: a file must have this exact size"],
+	["Must be at least {minimum, number}", "Validation error: a number is too small"],
+	["Must be greater than {minimum, number}", "Validation error: a number is too small"],
+	["Must be at most {maximum, number}", "Validation error: a number is too large"],
+	["Must be less than {maximum, number}", "Validation error: a number is too large"],
+	["Must be on or after {minimum, date, medium}", "Validation error: a date is too early"],
+	["Must be after {minimum, date, medium}", "Validation error: a date is too early"],
+	["Must be on or before {maximum, date, medium}", "Validation error: a date is too late"],
+	["Must be before {maximum, date, medium}", "Validation error: a date is too late"],
+	["Must be a multiple of {divisor, number}", "Validation error: a number is not a multiple"],
+	["Must be a valid email address", "Validation error"],
+	["Must be a valid URL", "Validation error"],
+	["Must start with “{prefix}”", "Validation error: {prefix} is the required beginning"],
+	["Must end with “{suffix}”", "Validation error: {suffix} is the required ending"],
+	["Must contain “{includes}”", "Validation error: {includes} is required text"],
+	["Invalid format", "Validation error: a text does not have the expected format"],
+	["Invalid option", "Validation error: a value is not one of the allowed options"],
+	["{count, plural, one {Unrecognized key: {keys}} other {Unrecognized keys: {keys}}}", "Validation error: an object has keys it must not have"],
+	["Invalid value", "Validation error"]
+];
+//#endregion
+//#region src/core/extract/scan.ts
+/**
+* The extraction scanner (INTERNALS §2.4, §2.5): finds vi18n calls by import
+* binding in one walk over a parsed module, turns literal messages into
+* occurrences and rewrite instructions, and reports build errors and
+* scan-time warnings. Bindings are resolved lexically, so a parameter or local
+* that shadows an imported `t` is never mistaken for it.
+*/
+/** Checks that need the source locale's plural rules (`ScanOptions.sourceLocale`). */
+const LOCALE_CODES = /* @__PURE__ */ new Set([
+	"icu-plural-missing-category",
+	"icu-plural-unused-category",
+	"icu-plural-one-literal"
+]);
+const EXPORTS = new Map([
+	"t",
+	"msg",
+	"rich",
+	"richHtml",
+	"richParts",
+	"preload",
+	"withLocale",
+	"createTranslator"
+].map((name) => [name, {
+	role: name,
+	api: name
+}]).concat([["vi18nZod", {
+	role: "zod",
+	api: "vi18nZod"
+}]]));
+/** Methods of a `createTranslator()` result, as bindings. */
+const TRANSLATOR_METHODS = new Map([
+	"t",
+	"rich",
+	"richHtml",
+	"richParts"
+].map((name) => [name, {
+	role: "translator",
+	api: name
+}]));
+/** `HELPER.useT` in `src/vite/types.ts`; core does not import the plugin layer. */
+const USE_T = "__vi18nUseT";
+const HOOK_SPECIFIERS = /* @__PURE__ */ new Set(["virtual:vi18n/glue/react", "virtual:vi18n/glue/preact"]);
+/** Import sources that are vi18n itself or generated glue, never a user wrapper. */
+function isWrapperSpecifier(specifier) {
+	return specifier !== "@menapo/vi18n" && specifier !== "@menapo/vi18n/server" && !specifier.startsWith("virtual:vi18n/");
+}
+const GLOBAL = {
+	role: "global",
+	api: "t"
+};
+const ALIAS = {
+	role: "alias",
+	api: "t"
+};
+const HOOK = {
+	role: "t",
+	api: "t"
+};
+const USE_T_BINDING = {
+	role: "useT",
+	api: USE_T
+};
+const TRANSLATOR_OBJECT = {
+	role: "translatorObject",
+	api: ""
+};
+/** The default export of a `.vue`/`.svelte` import source: a `<T>` rich-text component (§6 D214). */
+const COMPONENT = {
+	role: "component",
+	api: "rich"
+};
+const COMPONENT_SOURCE = /\.(?:vue|svelte)(?:\?.*)?$/;
+/** The props of a `<T>` that extraction reads; the others (slots, snippets, `values`) are code. */
+const COMPONENT_PROPS = /* @__PURE__ */ new Set([
+	"message",
+	"id",
+	"context",
+	"maxLength"
+]);
+/** Vue's compiled templates reach `<script setup>` bindings through these render parameters. */
+const VUE_CONTEXTS = /* @__PURE__ */ new Set(["$setup", "_ctx"]);
+/** §2.4: calls of these on a message argument build a string at runtime. */
+const STRING_METHODS = /* @__PURE__ */ new Set([
+	"concat",
+	"trim",
+	"trimStart",
+	"trimEnd",
+	"trimLeft",
+	"trimRight",
+	"toLowerCase",
+	"toUpperCase",
+	"toLocaleLowerCase",
+	"toLocaleUpperCase",
+	"replace",
+	"replaceAll",
+	"slice",
+	"substring",
+	"substr",
+	"padStart",
+	"padEnd",
+	"repeat",
+	"normalize",
+	"at",
+	"charAt",
+	"join",
+	"toString"
+]);
+/** Keys that hold only TypeScript types; nothing under them runs. */
+const TYPE_KEYS = /* @__PURE__ */ new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"typeArguments",
+	"superTypeArguments",
+	"returnType",
+	"implements"
+]);
+/** Statements with nothing to scan: type-only declarations, and imports and star re-exports (read by `listImports`). */
+const TYPE_ONLY = /* @__PURE__ */ new Set([
+	"TSTypeAliasDeclaration",
+	"TSInterfaceDeclaration",
+	"TSDeclareFunction",
+	"TSImportEqualsDeclaration",
+	"TSExportAssignment",
+	"TSNamespaceExportDeclaration",
+	"ImportDeclaration",
+	"ExportAllDeclaration"
+]);
+/** Leaves: nothing to visit below them. */
+const LEAVES = /* @__PURE__ */ new Set([
+	"Identifier",
+	"Literal",
+	"TemplateElement",
+	"ThisExpression",
+	"Super",
+	"PrivateIdentifier",
+	"MetaProperty",
+	"JSXText",
+	"JSXIdentifier",
+	"JSXEmptyExpression",
+	"EmptyStatement",
+	"DebuggerStatement",
+	"BreakStatement",
+	"ContinueStatement"
+]);
+/**
+* Child keys per node type in evaluation order. Types not listed are walked
+* through all their keys except {@link TYPE_KEYS}.
+*/
+const CHILDREN = /* @__PURE__ */ new Map([
+	["Program", ["body"]],
+	["ExpressionStatement", ["expression"]],
+	["ReturnStatement", ["argument"]],
+	["ThrowStatement", ["argument"]],
+	["IfStatement", [
+		"test",
+		"consequent",
+		"alternate"
+	]],
+	["WhileStatement", ["test", "body"]],
+	["DoWhileStatement", ["body", "test"]],
+	["LabeledStatement", ["body"]],
+	["WithStatement", ["object", "body"]],
+	["TryStatement", [
+		"block",
+		"handler",
+		"finalizer"
+	]],
+	["SwitchCase", ["test", "consequent"]],
+	["VariableDeclaration", ["declarations"]],
+	["VariableDeclarator", ["id", "init"]],
+	["ExportNamedDeclaration", ["declaration"]],
+	["ExportDefaultDeclaration", ["declaration"]],
+	["ClassDeclaration", [
+		"decorators",
+		"superClass",
+		"body"
+	]],
+	["ClassBody", ["body"]],
+	["Decorator", ["expression"]],
+	["ArrayExpression", ["elements"]],
+	["ObjectExpression", ["properties"]],
+	["SpreadElement", ["argument"]],
+	["UnaryExpression", ["argument"]],
+	["UpdateExpression", ["argument"]],
+	["AwaitExpression", ["argument"]],
+	["YieldExpression", ["argument"]],
+	["BinaryExpression", ["left", "right"]],
+	["LogicalExpression", ["left", "right"]],
+	["AssignmentExpression", ["left", "right"]],
+	["ConditionalExpression", [
+		"test",
+		"consequent",
+		"alternate"
+	]],
+	["NewExpression", ["callee", "arguments"]],
+	["SequenceExpression", ["expressions"]],
+	["TemplateLiteral", ["expressions"]],
+	["TaggedTemplateExpression", ["tag", "quasi"]],
+	["ChainExpression", ["expression"]],
+	["ParenthesizedExpression", ["expression"]],
+	["ImportExpression", ["source", "options"]],
+	["ObjectPattern", ["properties"]],
+	["ArrayPattern", ["elements"]],
+	["RestElement", ["argument"]],
+	["AssignmentPattern", ["left", "right"]],
+	["JSXElement", ["openingElement", "children"]],
+	["JSXOpeningElement", ["attributes"]],
+	["JSXFragment", ["children"]],
+	["JSXAttribute", ["value"]],
+	["JSXSpreadAttribute", ["argument"]],
+	["JSXExpressionContainer", ["expression"]],
+	["JSXSpreadChild", ["expression"]],
+	["TSAsExpression", ["expression"]],
+	["TSSatisfiesExpression", ["expression"]],
+	["TSNonNullExpression", ["expression"]],
+	["TSTypeAssertion", ["expression"]],
+	["TSInstantiationExpression", ["expression"]],
+	["TSParameterProperty", ["decorators", "parameter"]]
+]);
+/** {@link walkPlan}: nothing below the node runs (a leaf or type-only syntax). */
+const SKIP = null;
+/** {@link walkPlan}: walk every key except {@link TYPE_KEYS}. */
+const ALL_KEYS = void 0;
+/**
+* What `visitChildren` does with a node type, decided once per type instead
+* of three set lookups and two string tests per node: a scan visits every
+* node of every module that mentions vi18n.
+*/
+const PLANS = /* @__PURE__ */ new Map();
+function walkPlan(type) {
+	if (PLANS.has(type)) return PLANS.get(type);
+	const plan = LEAVES.has(type) || TYPE_ONLY.has(type) || type.startsWith("TS") && type.endsWith("Type") ? SKIP : CHILDREN.get(type);
+	PLANS.set(type, plan);
+	return plan;
+}
+/** `new Set(names)` per configured list: every module's scan gets the same arrays. */
+const NAME_SETS = /* @__PURE__ */ new WeakMap();
+function nameSet(names) {
+	let set = NAME_SETS.get(names);
+	if (set === void 0) NAME_SETS.set(names, set = new Set(names));
+	return set;
+}
+const PASS = null;
+const NO_DIAGNOSTICS = [];
+/**
+* Text `validateSource` certainly finds nothing in: ASCII without ICU syntax
+* (so it parses to one literal, has no apostrophe and no argument) and so
+* without the bidi controls and isolates its literal scan looks for.
+*/
+function isQuietPlainText(text) {
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c > 126 || c === 39 || c === 60 || c === 123 || c === 125) return false;
+	}
+	return true;
+}
+function snippet(code, node) {
+	const text = code.slice(node.start, node.end).replace(/\s+/g, " ");
+	return text.length > 60 ? `${text.slice(0, 57)}…` : text;
+}
+function stringValue(node) {
+	if (node.type === "Literal") return typeof node.value === "string" ? node.value : null;
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+		const cooked = (node.quasis[0]?.value)?.cooked;
+		return typeof cooked === "string" ? cooked : null;
+	}
+	return null;
+}
+/** Whether an object literal has a plain property named `name`. */
+function hasProperty(node, name) {
+	for (const property of node.properties) if (property.type === "Property" && keyName(property.key, property.computed === true) === name) return true;
+	return false;
+}
+/**
+* Whether a `const` initialiser holds message text that `t()` could never
+* look up: a literal that is not a manual id, a descriptor without an `id`,
+* or a choice (`? :`, `||`, `??`, `&&`) with such a branch. A value that
+* reaches `t()` through a variable is looked up as an id at runtime, so a
+* manual id there may be an `extraction.keep` id, and text built at runtime
+* a dynamic key: neither is reported.
+*/
+function textInit(init) {
+	const stack = [init];
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+		const node = unwrap(next);
+		switch (node.type) {
+			case "ConditionalExpression":
+				stack.push(node.alternate, node.consequent);
+				break;
+			case "LogicalExpression":
+				stack.push(node.right, node.left);
+				break;
+			case "Literal":
+			case "TemplateLiteral": {
+				const text = stringValue(node);
+				if (text !== null && !isValidManualId(text)) return true;
+				break;
+			}
+			case "ObjectExpression": if (hasProperty(node, "message") && !hasProperty(node, "id")) return true;
+		}
+	}
+	return false;
+}
+/** Offset after `from` and any whitespace, comments and `)` that follow it, never past `limit`. */
+function afterParens(code, from, limit) {
+	let at = from;
+	let i = from;
+	while (i < limit) {
+		const ch = code.charCodeAt(i);
+		if (ch === 41) at = ++i;
+		else if (ch === 47 && code[i + 1] === "*") {
+			const close = code.indexOf("*/", i + 2);
+			if (close === -1) break;
+			i = close + 2;
+		} else if (ch === 47 && code[i + 1] === "/") {
+			const close = code.indexOf("\n", i + 2);
+			if (close === -1) break;
+			i = close + 1;
+		} else if (/\s/.test(code[i])) i++;
+		else break;
+	}
+	return at;
+}
+const FUNCTIONS = /* @__PURE__ */ new Set([
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"FunctionDeclaration"
+]);
+/** True when `nodes` await or yield outside nested functions. Iterative: arguments can nest deeply. */
+function suspends(nodes) {
+	const stack = [...nodes];
+	for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+		if (node.type === "AwaitExpression" || node.type === "YieldExpression") return true;
+		if (FUNCTIONS.has(node.type)) continue;
+		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") stack.push(item);
+			} else if (typeof value.type === "string") stack.push(value);
+		}
+	}
+	return false;
+}
+var Scanner = class {
+	occurrences = [];
+	calls = [];
+	diagnostics = [];
+	/** `validateSource` per source text: a module often repeats a message. */
+	validated = /* @__PURE__ */ new Map();
+	/** {@link mentions}: per word, the first occurrence (`at`, or -1) at or after `from`. */
+	cursors = /* @__PURE__ */ new Map();
+	/**
+	* Message calls that were rewritten or reported as build errors
+	* (`extract-wrapper-unused`). Pass-through calls and helpers such as
+	* `preload` do not count: they say nothing about a wrapper's translation
+	* functions being configured.
+	*/
+	messageCalls = 0;
+	/** `vi18n-ignore` and `vi18n-context:` comments (§2.5.8), set before the walk. */
+	markers = {
+		ignored: [],
+		contexts: []
+	};
+	/** Offset of each occurrence's literal, for the context comments. */
+	literalStarts = [];
+	scope;
+	code;
+	options;
+	/** Names whose declarations matter: vi18n locals and globals. Others never get a scope entry. */
+	interesting = /* @__PURE__ */ new Set();
+	globals;
+	aliases;
+	/** Module-level bindings by local name, for Vue's `$setup.x` / `_ctx.x`. */
+	moduleVars;
+	/** Locals bound to Vue's `unref` (compiled templates call it `_unref`). */
+	unrefNames = /* @__PURE__ */ new Set(["_unref"]);
+	/** A `<T>` component is imported: calls are checked for it as their first argument. */
+	components = false;
+	fnDepth = 0;
+	withLocaleDepth = 0;
+	/** Start of the innermost expression statement or concise arrow body. */
+	leftEdge = -1;
+	/** The left edge starts a statement of a statement list ({@link ScanCallSite.asi}). */
+	leftEdgeAsi = false;
+	/** The statement a statement list is visiting, so an expression statement knows it sits in one. */
+	listStatement = null;
+	/** Variable declarators whose initialiser may create a translator or hook local, settled once their scope is complete. */
+	pendingInits = [];
+	/** Expressions inserted as HTML, marked before their calls are visited. */
+	sinks = null;
+	markSink = (node) => {
+		(this.sinks ??= /* @__PURE__ */ new WeakSet()).add(node);
+	};
+	constructor(code, options) {
+		this.code = code;
+		this.options = options;
+		this.globals = nameSet(options.globals);
+		this.aliases = nameSet(options.aliases);
+		for (const name of options.globals) this.interesting.add(name);
+		this.moduleVars = /* @__PURE__ */ new Map();
+		this.scope = {
+			vars: this.moduleVars,
+			parent: null
+		};
+	}
+	where(node) {
+		const where = { file: this.options.refFile };
+		if (node === null) return where;
+		if (this.options.exactPositions) Object.assign(where, lineColumn(this.code, node.start));
+		if (this.options.ranges === true) where.range = [node.start, node.end];
+		return where;
+	}
+	/**
+	* Under `vi18n-ignore`: warnings and the module-scope check, a policy the
+	* config sets. Errors stand, since each one is a message a production
+	* client would render as nothing.
+	*/
+	silenced(code, severity, node) {
+		return (severity === "warning" || code === "extract-module-scope") && this.markers.ignored.length > 0 && isIgnored(this.markers, node.start);
+	}
+	report(code, severity, message, node) {
+		if (this.silenced(code, severity, node)) return;
+		this.diagnostics.push({
+			code,
+			severity,
+			message,
+			...this.where(node)
+		});
+	}
+	/** Records the module's imports; returns the first wrapper import, if any. */
+	bindImports(parsed) {
+		const sources = this.options.sourceSpecifiers;
+		let wrapper = null;
+		for (const record of listImports(parsed)) {
+			const { specifier } = record;
+			if (sources.has(specifier)) {
+				if (wrapper === null && record.bindings.length > 0 && isWrapperSpecifier(specifier)) wrapper = {
+					specifier,
+					start: record.start
+				};
+				for (const { local, imported } of record.bindings) {
+					const binding = imported === "*" ? {
+						role: "namespace",
+						api: "",
+						specifier
+					} : this.exported(imported, specifier);
+					if (binding !== null) {
+						this.moduleVars.set(local, binding);
+						this.interesting.add(local);
+					} else if (this.interesting.has(local)) this.moduleVars.set(local, null);
+				}
+			} else for (const { local, imported } of record.bindings) {
+				if (specifier === "vue" && imported === "unref") this.unrefNames.add(local);
+				if (this.globals.has(local)) this.moduleVars.set(local, null);
+			}
+		}
+		return wrapper;
+	}
+	/** The binding an export of an import source gives, or null for other exports. */
+	exported(name, specifier) {
+		const binding = EXPORTS.get(name);
+		if (binding !== void 0) return binding;
+		if (name === "default" && COMPONENT_SOURCE.test(specifier)) {
+			this.components = true;
+			return COMPONENT;
+		}
+		if (this.aliases.has(name)) return ALIAS;
+		if (name === USE_T && HOOK_SPECIFIERS.has(specifier)) return USE_T_BINDING;
+		return null;
+	}
+	/** True when the module has anything a walk could find. */
+	get active() {
+		return this.interesting.size > 0;
+	}
+	resolveName(name) {
+		if (!this.interesting.has(name)) return null;
+		for (let scope = this.scope; scope !== null; scope = scope.parent) {
+			const found = scope.vars.get(name);
+			if (found !== void 0) return found;
+		}
+		return this.globals.has(name) ? GLOBAL : null;
+	}
+	isUnref(callee) {
+		const node = unwrap(callee);
+		return node.type === "Identifier" && this.unrefNames.has(node.name);
+	}
+	/** The vi18n binding an expression evaluates to, through every compiled shape of §2.4. */
+	resolveRef(input) {
+		const node = unwrap(input);
+		switch (node.type) {
+			case "Identifier": return this.resolveName(node.name);
+			case "SequenceExpression": {
+				const expressions = node.expressions;
+				const last = expressions[expressions.length - 1];
+				return last === void 0 ? null : this.resolveRef(last);
+			}
+			case "CallExpression": {
+				const args = node.arguments;
+				if (args.length !== 1 || !this.isUnref(node.callee)) return null;
+				const arg = args[0];
+				return arg.type === "SpreadElement" ? null : this.resolveRef(arg);
+			}
+			case "MemberExpression": {
+				const name = keyName(node.property, node.computed === true);
+				if (name === null) return null;
+				const object = unwrap(node.object);
+				if (object.type === "Identifier" && VUE_CONTEXTS.has(object.name)) {
+					const binding = this.moduleVars.get(name);
+					if (binding !== void 0) return binding;
+					return this.globals.has(name) ? GLOBAL : null;
+				}
+				if (object.type === "MemberExpression" && unwrap(object.object).type !== "Identifier") return null;
+				const owner = this.resolveRef(object);
+				if (owner === null) return null;
+				if (owner.role === "namespace") return this.exported(name, owner.specifier);
+				if (owner.role === "translatorObject") return TRANSLATOR_METHODS.get(name) ?? null;
+				return null;
+			}
+			default: return null;
+		}
+	}
+	/** The binding a call reaches and the index of its message argument. */
+	resolveCallee(callee) {
+		const node = unwrap(callee);
+		let binding;
+		let argIndex = 0;
+		if (node.type === "MemberExpression" && keyName(node.property, node.computed === true) === "call") {
+			binding = this.resolveRef(node.object);
+			if (binding !== null) argIndex = 1;
+			else binding = this.resolveRef(node);
+		} else binding = this.resolveRef(node);
+		if (binding === null || binding.role === "namespace" || binding.role === "translatorObject" || binding.role === "text") return null;
+		return {
+			binding,
+			argIndex
+		};
+	}
+	/**
+	* The initialiser of the `const` that `node` reads, when it holds message
+	* text (`textInit`), resolved lexically like the vi18n bindings. Vue dev
+	* templates read `<script setup>` bindings as `$setup.x`; Vue hoists their
+	* literal consts to module scope.
+	*/
+	textConst(node) {
+		let binding = null;
+		if (node.type === "Identifier") binding = this.resolveName(node.name);
+		else if (node.type === "MemberExpression") {
+			const object = unwrap(node.object);
+			const name = keyName(node.property, node.computed === true);
+			if (object.type === "Identifier" && object.name === "$setup" && name !== null) binding = this.moduleVars.get(name);
+		}
+		return binding?.role === "text" ? binding.init ?? null : null;
+	}
+	bind(vars, name, binding) {
+		if (binding === null && !this.interesting.has(name)) return vars;
+		const map = vars ?? /* @__PURE__ */ new Map();
+		map.set(name, binding);
+		if (binding !== null) this.interesting.add(name);
+		return map;
+	}
+	declarePattern(vars, pattern) {
+		if (pattern === null) return vars;
+		switch (pattern.type) {
+			case "Identifier": return this.bind(vars, pattern.name, null);
+			case "ObjectPattern":
+				for (const property of pattern.properties) vars = this.declarePattern(vars, property.type === "RestElement" ? property.argument : property.value);
+				return vars;
+			case "ArrayPattern":
+				for (const element of pattern.elements) vars = this.declarePattern(vars, element);
+				return vars;
+			case "AssignmentPattern": return this.declarePattern(vars, pattern.left);
+			case "RestElement": return this.declarePattern(vars, pattern.argument);
+			case "TSParameterProperty": return this.declarePattern(vars, pattern.parameter);
+			default: return vars;
+		}
+	}
+	/** The role of `init` when it creates a translator or a hook local, else null. */
+	initRole(init) {
+		if (init === null) return null;
+		let node = unwrap(init);
+		if (node.type === "AwaitExpression") node = unwrap(node.argument);
+		if (node.type !== "CallExpression") return null;
+		const role = this.resolveCallee(node.callee)?.binding.role;
+		return role === "createTranslator" || role === "useT" ? role : null;
+	}
+	/**
+	* Declares the names of a declaration. Initialisers that call something are
+	* queued for {@link settle}: their callee must be resolved in the scope being
+	* built, where a parameter or local may shadow `createTranslator` or
+	* `__vi18nUseT`. A `const` holding message text is bound as `text`, so the
+	* names that shadow it in inner scopes are recorded too.
+	*/
+	declareVariables(vars, declaration) {
+		const constant = declaration.kind === "const" && declaration.declare !== true;
+		for (const declarator of declaration.declarations) {
+			const id = declarator.id;
+			vars = this.declarePattern(vars, id);
+			const init = declarator.init;
+			if (init === null) continue;
+			let node = unwrap(init);
+			if (constant && id.type === "Identifier" && textInit(node)) vars = this.bind(vars, id.name, {
+				role: "text",
+				api: "",
+				init: node
+			});
+			if (node.type === "AwaitExpression") node = unwrap(node.argument);
+			if (node.type === "CallExpression") this.pendingInits.push(declarator);
+		}
+		return vars;
+	}
+	/** Binds the queued translator and hook locals of a scope whose declarations are all known. */
+	settle(vars) {
+		if (this.pendingInits.length === 0) return vars;
+		const declarators = this.pendingInits;
+		this.pendingInits = [];
+		const saved = this.scope;
+		for (const declarator of declarators) {
+			this.scope = vars === null || vars === saved.vars ? saved : {
+				vars,
+				parent: saved
+			};
+			const role = this.initRole(declarator.init);
+			this.scope = saved;
+			if (role !== null) vars = this.bindInit(vars, declarator.id, role);
+		}
+		return vars;
+	}
+	/** Binds a declarator's pattern for an initialiser of `role`, over what {@link declarePattern} bound. */
+	bindInit(vars, id, role) {
+		if (id.type === "Identifier") return this.bind(vars, id.name, role === "useT" ? HOOK : TRANSLATOR_OBJECT);
+		if (id.type !== "ObjectPattern" || role !== "createTranslator") return vars;
+		for (const property of id.properties) {
+			if (property.type !== "Property") continue;
+			const name = keyName(property.key, property.computed === true);
+			let target = property.value;
+			if (target.type === "AssignmentPattern") target = target.left;
+			const method = name === null ? void 0 : TRANSLATOR_METHODS.get(name);
+			if (method !== void 0 && target.type === "Identifier") vars = this.bind(vars, target.name, method);
+		}
+		return vars;
+	}
+	/** `var` declarations anywhere in a function body (not in nested functions). */
+	hoistVars(vars, statements) {
+		for (const statement of statements) vars = this.hoistIn(vars, statement);
+		return vars;
+	}
+	hoistIn(vars, statement) {
+		if (statement === null) return vars;
+		switch (statement.type) {
+			case "VariableDeclaration": return statement.kind === "var" ? this.declareVariables(vars, statement) : vars;
+			case "ExportNamedDeclaration": return this.hoistIn(vars, statement.declaration);
+			case "BlockStatement":
+			case "StaticBlock": return this.hoistVars(vars, statement.body);
+			case "IfStatement": {
+				let current = statement;
+				while (current?.type === "IfStatement") {
+					vars = this.hoistIn(vars, current.consequent);
+					current = current.alternate;
+				}
+				return this.hoistIn(vars, current);
+			}
+			case "ForStatement":
+				vars = this.hoistIn(vars, statement.init);
+				return this.hoistIn(vars, statement.body);
+			case "ForInStatement":
+			case "ForOfStatement":
+				vars = this.hoistIn(vars, statement.left);
+				return this.hoistIn(vars, statement.body);
+			case "WhileStatement":
+			case "DoWhileStatement":
+			case "LabeledStatement":
+			case "WithStatement": return this.hoistIn(vars, statement.body);
+			case "TryStatement": {
+				vars = this.hoistIn(vars, statement.block);
+				const handler = statement.handler;
+				if (handler !== null) vars = this.hoistIn(vars, handler.body);
+				return this.hoistIn(vars, statement.finalizer);
+			}
+			case "SwitchStatement":
+				for (const switchCase of statement.cases) vars = this.hoistVars(vars, switchCase.consequent);
+				return vars;
+			default: return vars;
+		}
+	}
+	/** Block-scoped declarations made directly in a statement list. */
+	lexical(vars, statements) {
+		for (let statement of statements) {
+			if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") && statement.declaration !== null) statement = statement.declaration;
+			switch (statement.type) {
+				case "VariableDeclaration":
+					if (statement.kind !== "var") vars = this.declareVariables(vars, statement);
+					break;
+				case "FunctionDeclaration":
+				case "ClassDeclaration":
+				case "TSEnumDeclaration":
+				case "TSModuleDeclaration": {
+					const id = statement.id;
+					if (id?.type === "Identifier") vars = this.bind(vars, id.name, null);
+					break;
+				}
+			}
+		}
+		return vars;
+	}
+	enter(vars) {
+		const saved = this.scope;
+		if (vars !== null) this.scope = {
+			vars,
+			parent: saved
+		};
+		return saved;
+	}
+	program(program) {
+		const body = program.body;
+		this.settle(this.lexical(this.hoistVars(this.moduleVars, body), body));
+		this.visitStatements(body);
+	}
+	/** A statement list: its expression statements may need {@link ScanCallSite.asi}. */
+	visitStatements(statements) {
+		for (const statement of statements) {
+			this.listStatement = statement;
+			this.visit(statement);
+		}
+	}
+	visitAll(nodes) {
+		for (const node of nodes) if (node !== null) this.visit(node);
+	}
+	visit(node) {
+		switch (node.type) {
+			case "CallExpression":
+				this.visitCall(node);
+				return;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				this.visitFunction(node);
+				return;
+			case "BlockStatement":
+			case "StaticBlock":
+				this.visitBlock(node);
+				return;
+			case "ForStatement":
+			case "ForInStatement":
+			case "ForOfStatement":
+				this.visitFor(node);
+				return;
+			case "CatchClause": {
+				const param = node.param;
+				const saved = this.enter(this.declarePattern(null, param));
+				if (param !== null) this.visit(param);
+				this.visitBlock(node.body);
+				this.scope = saved;
+				return;
+			}
+			case "SwitchStatement": {
+				this.visit(node.discriminant);
+				const cases = node.cases;
+				let vars = null;
+				for (const switchCase of cases) vars = this.lexical(vars, switchCase.consequent);
+				const saved = this.enter(this.settle(vars));
+				for (const switchCase of cases) {
+					if (switchCase.test !== null) this.visit(switchCase.test);
+					this.visitStatements(switchCase.consequent);
+				}
+				this.scope = saved;
+				return;
+			}
+			case "ClassExpression": {
+				const id = node.id;
+				const saved = this.enter(id === null ? null : this.bind(null, id.name, null));
+				this.visitAll(node.decorators ?? []);
+				if (node.superClass !== null) this.visit(node.superClass);
+				this.visit(node.body);
+				this.scope = saved;
+				return;
+			}
+			case "ExpressionStatement": {
+				const saved = this.leftEdge;
+				const savedAsi = this.leftEdgeAsi;
+				this.leftEdge = node.start;
+				this.leftEdgeAsi = node === this.listStatement;
+				this.visit(node.expression);
+				this.leftEdge = saved;
+				this.leftEdgeAsi = savedAsi;
+				return;
+			}
+			case "MemberExpression":
+				this.visitChain(node);
+				return;
+			case "IfStatement": {
+				let current = node;
+				while (current?.type === "IfStatement") {
+					this.visit(current.test);
+					this.visit(current.consequent);
+					current = current.alternate;
+				}
+				if (current !== null) this.visit(current);
+				return;
+			}
+			case "ConditionalExpression": {
+				let current = node;
+				while (current.type === "ConditionalExpression") {
+					this.visit(current.test);
+					this.visit(current.consequent);
+					current = current.alternate;
+				}
+				this.visit(current);
+				return;
+			}
+			case "Property":
+			case "MethodDefinition":
+			case "PropertyDefinition":
+			case "AccessorProperty":
+				if (this.options.warnings && node.type === "Property") markHtmlSinks(node, this.markSink);
+				if (node.decorators !== void 0) this.visitAll(node.decorators);
+				if (node.computed === true) this.visit(node.key);
+				if (node.value !== null && node.value !== void 0) this.visit(node.value);
+				return;
+			case "JSXAttribute":
+			case "AssignmentExpression":
+				if (this.options.warnings) markHtmlSinks(node, this.markSink);
+				break;
+			case "BinaryExpression":
+			case "LogicalExpression": {
+				const rights = [];
+				let current = node;
+				while (current.type === "BinaryExpression" || current.type === "LogicalExpression") {
+					rights.push(current.right);
+					current = current.left;
+				}
+				this.visit(current);
+				for (let i = rights.length - 1; i >= 0; i--) this.visit(rights[i]);
+				return;
+			}
+		}
+		this.visitChildren(node);
+	}
+	visitChildren(node) {
+		const keys = walkPlan(node.type);
+		if (keys === SKIP) return;
+		if (keys !== ALL_KEYS) {
+			for (const key of keys) {
+				const value = node[key];
+				if (value === null || typeof value !== "object") continue;
+				if (Array.isArray(value)) {
+					for (const item of value) if (item !== null) this.visit(item);
+				} else this.visit(value);
+			}
+			return;
+		}
+		for (const key in node) {
+			if (key === "type" || key === "start" || key === "end" || TYPE_KEYS.has(key)) continue;
+			this.visitValue(node[key]);
+		}
+	}
+	visitValue(value) {
+		if (value === null || typeof value !== "object") return;
+		if (Array.isArray(value)) for (const item of value) this.visitValue(item);
+		else if (typeof value.type === "string") this.visit(value);
+	}
+	visitBlock(block) {
+		const body = block.body;
+		let vars = this.lexical(null, body);
+		if (block.type === "StaticBlock") vars = this.hoistVars(vars, body);
+		const saved = this.enter(this.settle(vars));
+		this.visitStatements(body);
+		this.scope = saved;
+	}
+	visitFor(node) {
+		const head = node.type === "ForStatement" ? node.init : node.left;
+		const vars = head?.type === "VariableDeclaration" && head.kind !== "var" ? this.declareVariables(null, head) : null;
+		const saved = this.enter(this.settle(vars));
+		this.visitChildren(node);
+		this.scope = saved;
+	}
+	visitFunction(node) {
+		let vars = null;
+		const id = node.id;
+		if (node.type === "FunctionExpression" && id) vars = this.bind(vars, id.name, null);
+		const params = node.params;
+		for (const param of params) vars = this.declarePattern(vars, param);
+		const body = node.body;
+		const block = body !== null && body.type === "BlockStatement" ? body.body : null;
+		if (block !== null) vars = this.lexical(this.hoistVars(vars, block), block);
+		const saved = this.enter(this.settle(vars));
+		const savedEdge = this.leftEdge;
+		const savedAsi = this.leftEdgeAsi;
+		this.fnDepth++;
+		this.visitAll(params);
+		if (block !== null) this.visitStatements(block);
+		else if (body !== null) {
+			this.leftEdge = body.start;
+			this.leftEdgeAsi = false;
+			this.visit(body);
+		}
+		this.fnDepth--;
+		this.leftEdge = savedEdge;
+		this.leftEdgeAsi = savedAsi;
+		this.scope = saved;
+	}
+	/**
+	* Member and unrecognised call chains (`x.a().b().c()`) nest to the left:
+	* walk down the spine in a loop, then visit each link's own parts in
+	* evaluation order, so long generated chains never exhaust the stack.
+	*/
+	visitChain(node) {
+		const links = [];
+		let current = node;
+		for (;;) if (current.type === "MemberExpression") {
+			links.push(current);
+			current = current.object;
+		} else if (current.type === "CallExpression" && this.resolveCallee(current.callee) === null) {
+			links.push(current);
+			current = current.callee;
+		} else break;
+		this.visit(current);
+		for (let i = links.length - 1; i >= 0; i--) {
+			const link = links[i];
+			if (link.type === "MemberExpression") {
+				if (link.computed === true) this.visit(link.property);
+			} else {
+				if (this.options.warnings) markHtmlSinks(link, this.markSink);
+				this.visitAll(link.arguments);
+			}
+		}
+	}
+	visitCall(node) {
+		const resolved = this.resolveCallee(node.callee);
+		const args = node.arguments;
+		if (resolved === null) {
+			const first = args[0];
+			if (this.components && first !== void 0 && this.resolveRef(first)?.role === "component" && this.componentCall(node, args)) return;
+			this.visitChain(node);
+			return;
+		}
+		const { binding, argIndex } = resolved;
+		switch (binding.role) {
+			case "component":
+				if (!this.componentCall(node, args)) {
+					this.visit(node.callee);
+					this.visitAll(args);
+				}
+				return;
+			case "withLocale":
+				this.visit(node.callee);
+				this.withLocaleDepth++;
+				this.visitAll(args);
+				this.withLocaleDepth--;
+				return;
+			case "preload": {
+				const load = args[argIndex];
+				if (load !== void 0 && load.type !== "SpreadElement" && args.length === argIndex + 1) this.calls.push({
+					kind: "preload",
+					occurrence: -1,
+					start: node.start,
+					end: node.end,
+					insertAt: afterParens(this.code, load.end, node.end - 1),
+					callStart: node.start,
+					callEnd: node.end
+				});
+				this.visit(node.callee);
+				this.visitAll(args);
+				return;
+			}
+			case "createTranslator":
+			case "useT":
+				this.visit(node.callee);
+				this.visitAll(args);
+				return;
+			case "zod":
+				this.zodCall(node);
+				this.visit(node.callee);
+				this.visitAll(args);
+				return;
+		}
+		this.messageCall(node, binding, args, argIndex);
+	}
+	/**
+	* A `<T>` component rendered with props `args[1]` (§2.4 "Rich-text
+	* components"): a literal `message` prop is extracted like a `rich()`
+	* message and rewritten in place, with `id`, `context` and `maxLength`
+	* props read as a descriptor's. A computed message is a runtime id, as in
+	* `rich(props.label)`; text built from substitutions (Svelte's
+	* `message="Hi {name}"`) is `extract-dynamic-message`. False when the
+	* props hold no `message`.
+	*/
+	componentCall(node, args) {
+		const props = args[1] === void 0 ? null : unwrap(args[1]);
+		if (props?.type !== "ObjectExpression") return false;
+		const read = [];
+		let message = null;
+		for (const property of props.properties) {
+			if (property.type !== "Property" || property.computed === true) continue;
+			const key = keyName(property.key, false);
+			if (key === null || !COMPONENT_PROPS.has(key)) continue;
+			read.push(property);
+			if (key !== "message") continue;
+			message = unwrap(property.value);
+			if (property.kind === "get") {
+				const body = message.body?.body;
+				const returned = body?.length === 1 && body[0]?.type === "ReturnStatement" ? body[0] : null;
+				message = returned?.argument ? unwrap(returned.argument) : message;
+			}
+		}
+		if (message === null) return false;
+		const analysis = stringValue(message) === null ? this.analyse(message, false, "T") : this.descriptor({
+			...props,
+			properties: read
+		});
+		if (analysis !== PASS) this.messageCalls++;
+		if (analysis !== PASS && !analysis.ok) this.report(analysis.code, "error", analysis.message, analysis.node);
+		else if (analysis !== PASS) {
+			const callee = node.callee;
+			const occurrence = this.occurrence(analysis, "rich", callee);
+			if (occurrence !== null) {
+				this.calls.push({
+					kind: "rich",
+					occurrence: this.occurrences.length,
+					start: analysis.literal.start,
+					end: analysis.literal.end,
+					callStart: node.start,
+					callEnd: node.end
+				});
+				this.occurrences.push(occurrence);
+			}
+		}
+		this.visit(node.callee);
+		this.visitAll(args);
+		return true;
+	}
+	/**
+	* `vi18nZod()` (INTERNALS §6 D206): one `msg()` occurrence per bridge
+	* message, at the call, and one site each that inserts its rewritten form
+	* as a leading argument, in `ZOD_MESSAGES` order. They are vi18n's own
+	* messages, validated by its tests, so the project's source-locale checks
+	* do not run on them.
+	*/
+	zodCall(node) {
+		const callee = node.callee;
+		const from = Math.max(callee.end, node.typeArguments?.end ?? 0);
+		const insertAt = this.code.indexOf("(", afterParens(this.code, from, node.end - 1)) + 1;
+		for (const [source, context] of ZOD_MESSAGES) {
+			const occurrence = this.occurrence({
+				ok: true,
+				source,
+				literal: node,
+				context
+			}, "msg", callee, false);
+			if (occurrence === null) continue;
+			this.calls.push({
+				kind: "zod",
+				occurrence: this.occurrences.length,
+				start: insertAt,
+				end: insertAt,
+				insertAt,
+				callStart: node.start,
+				callEnd: node.end
+			});
+			this.occurrences.push(occurrence);
+		}
+	}
+	messageCall(node, binding, args, argIndex) {
+		const callee = node.callee;
+		const kind = binding.role;
+		if (this.fnDepth === 0 && this.withLocaleDepth === 0 && this.options.moduleScope !== "off" && kind !== "msg" && kind !== "translator" && !this.silenced("extract-module-scope", "warning", node)) this.diagnostics.push(moduleScopeDiagnostic(snippet(this.code, callee), this.options.moduleScope === "error" ? "error" : "warning", this.where(node)));
+		const arg = args[argIndex];
+		let analysis;
+		if (kind === "msg" && args.length > argIndex + 1) analysis = this.extraArguments(node);
+		else if (arg !== void 0 && arg.type !== "SpreadElement") analysis = this.analyse(arg, kind === "msg", binding.api);
+		else if (kind === "msg") analysis = this.missingMessage(node);
+		else analysis = PASS;
+		if (analysis !== PASS) this.messageCalls++;
+		if (analysis === PASS || !analysis.ok) {
+			if (analysis !== PASS) this.report(analysis.code, "error", analysis.message, analysis.node);
+			this.visit(callee);
+			for (const value of args) if (analysis !== PASS && value === arg && analysis.inline !== void 0) this.visitAll(analysis.inline.arguments);
+			else this.visit(value);
+			return;
+		}
+		const occurrence = this.occurrence(analysis, kind, callee);
+		if (occurrence !== null) {
+			const top = kind === "msg";
+			const site = {
+				kind,
+				occurrence: this.occurrences.length,
+				start: top ? node.start : arg.start,
+				end: top ? node.end : arg.end,
+				callStart: node.start,
+				callEnd: node.end
+			};
+			if (node.start === this.leftEdge) {
+				if (top) site.parenthesize = true;
+				if (this.leftEdgeAsi) site.asi = true;
+			}
+			if (!top && this.awaitsOrYields(node, args)) site.argsAt = afterParens(this.code, Math.max(callee.end, node.typeArguments?.end ?? 0), node.end - 1);
+			this.occurrences.push(occurrence);
+			this.literalStarts.push(analysis.literal.start);
+			this.calls.push(site);
+			if (binding.api === "t" && this.sinks?.has(node) && !this.silenced("extract-html-sink", "warning", node)) this.diagnostics.push(htmlSinkDiagnostic(snippet(this.code, callee), occurrence.id, this.where(node)));
+		}
+		this.visit(callee);
+		for (const value of args) if (value !== arg) this.visit(value);
+	}
+	occurrence(analysis, kind, callee, validate = true) {
+		const { codec } = this.options;
+		let canonical;
+		try {
+			canonical = codec.canonicalize(analysis.source);
+		} catch (error) {
+			if (!isDiagnosticError(error)) throw error;
+			const { code, severity, message } = error.diagnostic;
+			this.report(code, severity, `${message} in ${snippet(this.code, callee)}(${snippet(this.code, analysis.literal)})`, analysis.literal);
+			return null;
+		}
+		if (validate) this.validate(analysis, callee);
+		const label = codec.label(canonical);
+		const position = this.options.exactPositions ? lineColumn(this.code, analysis.literal.start) : {
+			line: 0,
+			column: 0
+		};
+		const occurrence = {
+			id: analysis.id ?? label,
+			manual: analysis.id !== void 0,
+			source: analysis.source,
+			canonical,
+			sourceHash: codec.sourceHash(canonical),
+			label,
+			callee: kind,
+			file: this.options.refFile,
+			line: position.line,
+			column: position.column
+		};
+		if (analysis.context !== void 0) occurrence.context = analysis.context;
+		if (analysis.maxLength !== void 0) occurrence.maxLength = analysis.maxLength;
+		return occurrence;
+	}
+	/**
+	* The source checks of §2.1.3 that parsing does not make (bidi controls,
+	* unbalanced isolates, argument kinds, plural categories, apostrophes), so
+	* a source the catalogs would reject as a translation is not extracted
+	* silently. Positions inside the message give way to the literal's.
+	*/
+	validate(analysis, callee) {
+		const { source } = analysis;
+		let found = this.validated.get(source);
+		if (found === void 0 && isQuietPlainText(source)) found = NO_DIAGNOSTICS;
+		if (found === void 0) {
+			const locale = this.options.sourceLocale;
+			found = validateSource(this.options.codec.parse(source), {
+				locale: locale ?? "und",
+				text: source
+			});
+			if (locale === void 0) found = found.filter((d) => !LOCALE_CODES.has(d.code));
+			this.validated.set(source, found);
+		}
+		for (const { code, severity, message } of found) this.report(code, severity, `${message} in ${snippet(this.code, callee)}(${snippet(this.code, analysis.literal)})`, analysis.literal);
+	}
+	/**
+	* Classifies a message argument (§2.4); `PASS` leaves it to the runtime.
+	* `api` names the called function in hints.
+	*/
+	analyse(arg, isMsg, api) {
+		let node = unwrap(arg);
+		if (node.type === "ChainExpression") node = unwrap(node.expression);
+		const dynamic = () => ({
+			ok: false,
+			code: "extract-dynamic-message",
+			message: isMsg ? `msg() declares a message and takes only a string literal or a { message } object literal, not ${snippet(this.code, node)}` : `A message must be a literal, not a computed string (${snippet(this.code, node)}); pass values as ICU arguments such as "Hello {name}"`,
+			node
+		});
+		switch (node.type) {
+			case "Literal":
+				if (typeof node.value === "string") return {
+					ok: true,
+					source: node.value,
+					literal: node
+				};
+				break;
+			case "TemplateLiteral": {
+				const value = stringValue(node);
+				return value === null ? dynamic() : {
+					ok: true,
+					source: value,
+					literal: node
+				};
+			}
+			case "BinaryExpression":
+				if (node.operator === "+") return dynamic();
+				break;
+			case "ObjectExpression": return this.descriptor(node);
+			case "CallExpression":
+				if (!isMsg) {
+					const inner = this.resolveCallee(node.callee);
+					if (inner?.binding.role === "msg") {
+						const innerArgs = node.arguments;
+						const value = innerArgs[inner.argIndex];
+						const result = innerArgs.length > inner.argIndex + 1 ? this.extraArguments(node) : value === void 0 || value.type === "SpreadElement" ? this.missingMessage(node) : this.analyse(value, true, "msg");
+						return result.ok ? result : {
+							...result,
+							inline: node
+						};
+					}
+				}
+				if (this.buildsString(node)) return dynamic();
+				break;
+			case "ConditionalExpression":
+			case "LogicalExpression":
+				if (this.choiceText(node) !== null) return this.choice(node, isMsg ? "msg" : api);
+				break;
+			case "Identifier":
+			case "MemberExpression": {
+				if (isMsg) break;
+				const init = this.textConst(node);
+				if (init !== null) return {
+					ok: false,
+					code: "extract-dynamic-message",
+					message: `${snippet(this.code, node)} holds message text (${snippet(this.code, init)}) that extraction cannot see through a variable; pass the literal to ${api}() directly, or declare it with msg()`,
+					node
+				};
+				break;
+			}
+		}
+		return isMsg ? dynamic() : PASS;
+	}
+	/**
+	* The first branch of a `? :`, `||`, `??` or `&&` argument that would be
+	* message text, or a build error, passed on its own; null when every branch
+	* is left to the runtime. `msg()` branches are references, extracted where
+	* they stand.
+	*/
+	choiceText(node) {
+		const stack = [node];
+		for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+			let branch = unwrap(next);
+			if (branch.type === "ChainExpression") branch = unwrap(branch.expression);
+			switch (branch.type) {
+				case "ConditionalExpression":
+					stack.push(branch.alternate, branch.consequent);
+					break;
+				case "LogicalExpression":
+					stack.push(branch.right, branch.left);
+					break;
+				case "Literal":
+					if (typeof branch.value === "string") return branch;
+					break;
+				case "TemplateLiteral":
+				case "ObjectExpression": return branch;
+				case "BinaryExpression":
+					if (branch.operator === "+") return branch;
+					break;
+				case "CallExpression":
+					if (this.buildsString(branch)) return branch;
+					break;
+				case "Identifier":
+				case "MemberExpression": if (this.textConst(branch) !== null) return branch;
+			}
+		}
+		return null;
+	}
+	/** `extract-dynamic-message` for a choice between texts, with the rewrite that works. */
+	choice(node, api) {
+		const hint = node.type === "ConditionalExpression" ? `cond ? ${api}("A") : ${api}("B")` : `x ${node.operator} ${api}("B")`;
+		return {
+			ok: false,
+			code: "extract-dynamic-message",
+			message: `A message must be one literal, not a choice between texts (${snippet(this.code, node)}); write ${hint}`,
+			node
+		};
+	}
+	/** Cheap text test first: almost no call has `await` or `yield` in it. */
+	awaitsOrYields(call, args) {
+		return (this.mentions("await", call.start, call.end) || this.mentions("yield", call.start, call.end)) && suspends(args);
+	}
+	/**
+	* Whether `word` occurs in `code[start, end)`, without copying the range.
+	* An unbounded `indexOf` runs to the next occurrence anywhere after
+	* `start`, often the end of the file, so each word keeps the occurrence it
+	* last found: calls are visited in source order, and while that occurrence
+	* is still at or after `start` it is the first one there. That keeps a
+	* module's searches linear in its size, not in calls × size.
+	*/
+	mentions(word, start, end) {
+		let cursor = this.cursors.get(word);
+		if (cursor === void 0 || start < cursor.from || cursor.at !== -1 && cursor.at < start) {
+			cursor = {
+				from: start,
+				at: this.code.indexOf(word, start)
+			};
+			this.cursors.set(word, cursor);
+		}
+		return cursor.at !== -1 && cursor.at + word.length <= end;
+	}
+	/**
+	* `msg()` is replaced as a whole, so arguments past the message would vanish
+	* with their side effects, and calls inside them would be rewritten inside
+	* text already replaced.
+	*/
+	extraArguments(call) {
+		return {
+			ok: false,
+			code: "extract-dynamic-message",
+			message: "msg() takes exactly one argument, the message",
+			node: call
+		};
+	}
+	missingMessage(call) {
+		return {
+			ok: false,
+			code: "extract-dynamic-message",
+			message: "msg() needs a string literal or a { message } object literal",
+			node: call
+		};
+	}
+	/** `String(…)` or a string-method call: a string computed at runtime. */
+	buildsString(call) {
+		let callee = unwrap(call.callee);
+		if (callee.type === "ChainExpression") callee = unwrap(callee.expression);
+		if (callee.type === "Identifier") return callee.name === "String";
+		if (callee.type !== "MemberExpression") return false;
+		const name = keyName(callee.property, callee.computed === true);
+		return name !== null && STRING_METHODS.has(name);
+	}
+	/** `{ id?, message, context?, maxLength? }` with literal values only. */
+	descriptor(node) {
+		const invalid = (what, at) => ({
+			ok: false,
+			code: "extract-non-literal-option",
+			message: `A message descriptor takes only literal id, message, context and maxLength properties: ${what}`,
+			node: at
+		});
+		let source;
+		let literal;
+		let id;
+		let idNode;
+		let context;
+		let maxLength;
+		for (const property of node.properties) {
+			if (property.type !== "Property" || property.kind !== "init" || property.method === true) return invalid(`${snippet(this.code, property)} is not a plain property`, property);
+			const key = keyName(property.key, property.computed === true);
+			const value = unwrap(property.value);
+			switch (key) {
+				case "message": {
+					const text = stringValue(value);
+					if (text === null) return invalid(`message is ${snippet(this.code, value)}`, value);
+					source = text;
+					literal = value;
+					break;
+				}
+				case "context": {
+					const text = stringValue(value);
+					if (text === null) return invalid(`context is ${snippet(this.code, value)}`, value);
+					context = text;
+					break;
+				}
+				case "id": {
+					const text = stringValue(value);
+					if (text === null) return invalid(`id is ${snippet(this.code, value)}`, value);
+					if (!isValidManualId(text)) return {
+						ok: false,
+						code: "extract-invalid-manual-id",
+						message: `Manual id ${JSON.stringify(text)} is invalid; use two or more dot-separated segments of letters, digits, "_", ":" and "-", such as "hero.cta"`,
+						node: value
+					};
+					id = text;
+					idNode = value;
+					break;
+				}
+				case "maxLength":
+					if (value.type !== "Literal" || typeof value.value !== "number" || !Number.isInteger(value.value) || value.value <= 0) return invalid(`maxLength is ${snippet(this.code, value)}, not a positive integer`, value);
+					maxLength = value.value;
+					break;
+				default: return invalid(`unknown property ${snippet(this.code, property.key)}`, property);
+			}
+		}
+		if (source === void 0 || literal === void 0) {
+			const library = id === void 0 ? void 0 : this.options.libraryIds?.get(id);
+			if (library === void 0 || idNode === void 0) return invalid(id === void 0 ? "the message property is missing" : `the message property is missing, and no package in extraction.dependencies declares ${JSON.stringify(id)} in its vi18n.messages.json`, node);
+			source = library;
+			literal = idNode;
+		}
+		const result = {
+			ok: true,
+			source,
+			literal
+		};
+		if (id !== void 0) result.id = id;
+		if (context !== void 0) result.context = context;
+		if (maxLength !== void 0) result.maxLength = maxLength;
+		return result;
+	}
+};
+/**
+* Gives each `vi18n-context:` note to the first message (by position) in the
+* code it applies to, after any descriptor `context`, as a second note.
+*/
+function attachContexts(markers, occurrences, literalStarts) {
+	for (const { note, start, end } of markers.contexts) {
+		let first = -1;
+		for (let i = 0; i < occurrences.length; i++) {
+			const at = literalStarts[i];
+			if (at >= start && at < end && (first === -1 || at < literalStarts[first])) first = i;
+		}
+		if (first === -1) continue;
+		const occurrence = occurrences[first];
+		occurrence.context = occurrence.context === void 0 ? note : `${occurrence.context}\n${note}`;
+	}
+}
+/**
+* Scans one module (INTERNALS §2.5.5): every vi18n call with a literal
+* message becomes a {@link MessageOccurrence} and a call site for
+* `rewriteModule`; computed messages and bad descriptors are build errors;
+* other arguments pass through to the runtime untouched. `calls` holds
+* {@link ScanCallSite}s.
+*/
+function scanModule(parsed, options) {
+	const scanner = new Scanner(parsed.code, options);
+	const wrapper = scanner.bindImports(parsed);
+	if (scanner.active) {
+		scanner.markers = markersOf(parsed);
+		try {
+			scanner.program(parsed.program);
+		} catch (error) {
+			if (!(error instanceof RangeError) || !/call stack/i.test(error.message)) throw error;
+			throw diagnosticError({
+				code: "extract-parse-error",
+				severity: "error",
+				message: `Cannot scan ${options.refFile}: its code is nested too deeply`,
+				file: options.refFile
+			});
+		}
+	}
+	if (options.warnings && wrapper !== null && scanner.messageCalls === 0 && !isIgnored(markersOf(parsed), wrapper.start)) {
+		const where = { file: options.refFile };
+		if (options.exactPositions) Object.assign(where, lineColumn(parsed.code, wrapper.start));
+		scanner.diagnostics.push(wrapperUnusedDiagnostic(wrapper.specifier, where));
+	}
+	attachContexts(scanner.markers, scanner.occurrences, scanner.literalStarts);
+	return {
+		occurrences: scanner.occurrences,
+		calls: scanner.calls,
+		diagnostics: scanner.diagnostics,
+		importsWrapper: wrapper !== null
+	};
+}
+//#endregion
+//#region src/core/extract/sources.ts
+/**
+* Which import specifiers of a module are vi18n sources for the CLI (INTERNALS
+* §2.5.2). The plugin asks Vite's resolver; the CLI has none, so a specifier
+* counts when it equals an `extraction.importSources` entry, when it is
+* relative and resolves to a wrapper's file, or when it is alias-shaped
+* (`$lib/i18n`, `@/lib/i18n`) and ends in a wrapper's basename (§6 D13).
+*/
+/** Probed after an extensionless relative specifier, in this order (§2.5.2). */
+const PROBE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".mts"
+];
+/** Script extensions a specifier's last segment may carry (`./i18n.js` names `i18n.ts` in TS ESM). */
+const SCRIPT_EXTENSION = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+/** TypeScript's ESM convention: an import written `.js` names the `.ts` file. */
+const TS_TWINS = {
+	".js": [".ts", ".tsx"],
+	".jsx": [".tsx"],
+	".mjs": [".mts"],
+	".cjs": [".cts"]
+};
+const infos = /* @__PURE__ */ new WeakMap();
+function isRelative(specifier) {
+	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+/** The last path segment without a script extension and without a `?query`. */
+function lastName(specifier) {
+	const query = specifier.indexOf("?");
+	const path = query === -1 ? specifier : specifier.slice(0, query);
+	return path.slice(path.lastIndexOf("/") + 1).replace(SCRIPT_EXTENSION, "");
+}
+function isFile(path) {
+	return statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+}
+function real(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+/**
+* The module file a path names, with the extension probing of §2.5.2: as
+* written, with each probed extension, with the `.js` → `.ts` twin, then as a
+* directory's `index.*`. Returns its realpath, as the file walk lists files.
+*/
+function probeModule(path) {
+	const query = path.indexOf("?");
+	if (query !== -1) path = path.slice(0, query);
+	if (isFile(path)) return real(path);
+	for (const ext of PROBE_EXTENSIONS) if (isFile(path + ext)) return real(path + ext);
+	const ext = /\.[cm]?jsx?$/.exec(path)?.[0];
+	if (ext !== void 0) {
+		const stem = path.slice(0, -ext.length);
+		for (const twin of TS_TWINS[ext] ?? []) if (isFile(stem + twin)) return real(stem + twin);
+	}
+	for (const ext of PROBE_EXTENSIONS) {
+		const index = join(path, "index" + ext);
+		if (isFile(index)) return real(index);
+	}
+	return null;
+}
+/**
+* JSONC as tsconfig files are written: comments and trailing commas removed
+* outside strings.
+*/
+function parseJsonc(text) {
+	let out = "";
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === "\"") {
+			let j = i + 1;
+			while (j < text.length && text[j] !== "\"") j += text[j] === "\\" ? 2 : 1;
+			out += text.slice(i, j + 1);
+			i = j;
+		} else if (ch === "/" && text[i + 1] === "/") {
+			while (i < text.length && text[i] !== "\n") i++;
+			out += "\n";
+		} else if (ch === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			i = end === -1 ? text.length : end + 1;
+		} else out += ch;
+	}
+	return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+function readJson(file, jsonc) {
+	try {
+		const text = readFileSync(file, "utf8");
+		const value = jsonc ? parseJsonc(text) : JSON.parse(text);
+		return typeof value === "object" && value !== null ? value : null;
+	} catch {
+		return null;
+	}
+}
+/** The first target a `package.json` `imports` value names, by condition order. */
+function conditionTarget(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const target = conditionTarget(item);
+			if (target !== null) return target;
+		}
+		return null;
+	}
+	if (typeof value !== "object" || value === null) return null;
+	for (const [condition, item] of Object.entries(value)) {
+		if (condition === "types") continue;
+		if (condition === "import" || condition === "module" || condition === "node" || condition === "default" || condition === "development" || condition === "production") {
+			const target = conditionTarget(item);
+			if (target !== null) return target;
+		}
+	}
+	return null;
+}
+/** Applies a `*` pattern map (`imports`, tsconfig `paths`) to `specifier`. */
+function patternMatch(keys, specifier) {
+	if (keys.includes(specifier)) return {
+		key: specifier,
+		star: ""
+	};
+	let best = null;
+	for (const key of keys) {
+		const at = key.indexOf("*");
+		if (at === -1) continue;
+		const prefix = key.slice(0, at);
+		const suffix = key.slice(at + 1);
+		if (specifier.length >= prefix.length + suffix.length && specifier.startsWith(prefix) && specifier.endsWith(suffix) && (best === null || prefix.length > best.key.indexOf("*"))) best = {
+			key,
+			star: specifier.slice(prefix.length, specifier.length - suffix.length)
+		};
+	}
+	return best;
+}
+/** `#…` through the nearest `package.json` `imports` above the config root. */
+function resolvePackageImport(root, specifier) {
+	for (let dir = root;; dir = dirname(dir)) {
+		const pkg = readJson(join(dir, "package.json"), false);
+		if (pkg !== null) {
+			const imports = pkg.imports;
+			if (typeof imports !== "object" || imports === null) return null;
+			const map = imports;
+			const hit = patternMatch(Object.keys(map), specifier);
+			if (hit === null) return null;
+			const target = conditionTarget(map[hit.key]);
+			if (target === null || !target.startsWith("./")) return null;
+			return probeModule(resolve(dir, target.replaceAll("*", hit.star)));
+		}
+		if (dirname(dir) === dir) return null;
+	}
+}
+/** `compilerOptions.paths` in effect for `file`, following relative and package `extends`. */
+function tsconfigPaths(file, depth = 0) {
+	const json = readJson(file, true);
+	if (json === null || depth > 8) return null;
+	const options = json.compilerOptions;
+	const dir = dirname(file);
+	const baseUrl = typeof options?.baseUrl === "string" ? resolve(dir, options.baseUrl) : null;
+	if (typeof options?.paths === "object" && options.paths !== null) return {
+		base: baseUrl ?? dir,
+		paths: options.paths
+	};
+	const parents = typeof json.extends === "string" ? [json.extends] : json.extends;
+	if (!Array.isArray(parents)) return null;
+	for (let i = parents.length - 1; i >= 0; i--) {
+		const parent = parents[i];
+		if (typeof parent !== "string") continue;
+		let parentFile = null;
+		if (isRelative(parent) || isAbsolute(parent)) {
+			const candidate = resolve(dir, parent);
+			parentFile = isFile(candidate) ? candidate : isFile(candidate + ".json") ? candidate + ".json" : null;
+		} else try {
+			parentFile = createRequire(file).resolve(parent);
+		} catch {
+			parentFile = null;
+		}
+		if (parentFile === null) continue;
+		const inherited = tsconfigPaths(parentFile, depth + 1);
+		if (inherited !== null) return baseUrl === null ? inherited : {
+			base: baseUrl,
+			paths: inherited.paths
+		};
+	}
+	return null;
+}
+function resolveTsPath(root, specifier) {
+	for (const name of ["tsconfig.json", "jsconfig.json"]) {
+		const file = join(root, name);
+		if (!isFile(file)) continue;
+		const config = tsconfigPaths(file);
+		if (config === null) continue;
+		const hit = patternMatch(Object.keys(config.paths), specifier);
+		if (hit === null) continue;
+		const targets = config.paths[hit.key];
+		if (!Array.isArray(targets)) continue;
+		for (const target of targets) {
+			if (typeof target !== "string") continue;
+			const found = probeModule(resolve(config.base, target.replaceAll("*", hit.star)));
+			if (found !== null) return found;
+		}
+	}
+	return null;
+}
+/**
+* The wrapper's file as Vite would most likely resolve it: a path relative
+* to the config root, a `#` subpath import, a tsconfig `paths` alias, or a
+* (workspace) package. Vite aliases live in the Vite config, which the CLI
+* does not load, so some alias wrappers stay unresolved.
+*/
+function resolveWrapper(root, specifier) {
+	const path = (file) => file === null ? null : {
+		file,
+		package: false
+	};
+	if (isRelative(specifier)) return path(probeModule(resolve(root, specifier)));
+	if (isAbsolute(specifier)) return path(probeModule(specifier) ?? probeModule(join(root, specifier)));
+	if (specifier.startsWith("#")) return path(resolvePackageImport(root, specifier));
+	const aliased = resolveTsPath(root, specifier);
+	if (aliased !== null) return path(aliased);
+	try {
+		return {
+			file: real(createRequire(join(root, "package.json")).resolve(specifier)),
+			package: true
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* The name an alias-form import of a wrapper written `specifier` ends in:
+* its last segment, or for `…/i18n/index` the directory's (an `index` name
+* would make every `…/index` import a source).
+*/
+function writtenName(specifier) {
+	const name = lastName(specifier);
+	if (name !== "index") return name;
+	const query = specifier.indexOf("?");
+	const path = query === -1 ? specifier : specifier.slice(0, query);
+	return lastName(path.slice(0, Math.max(0, path.lastIndexOf("/"))));
+}
+function sourceInfo(config) {
+	const known = infos.get(config);
+	if (known !== void 0 && known.importSources === config.extraction.importSources && known.root === config.root) return known;
+	const entries = new Set(config.extraction.importSources);
+	const names = /* @__PURE__ */ new Set();
+	const unresolved = /* @__PURE__ */ new Set();
+	const probe = /* @__PURE__ */ new Set();
+	const files = /* @__PURE__ */ new Set();
+	const usable = (name) => name !== "" && name !== "." && name !== ".." && name !== "index";
+	for (const specifier of entries) {
+		if (DEFAULT_IMPORT_SOURCES.includes(specifier)) continue;
+		const wrapper = resolveWrapper(config.root, specifier);
+		const written = writtenName(specifier);
+		if (usable(written)) names.add(written);
+		if (wrapper === null) {
+			if (usable(written)) unresolved.add(written);
+			continue;
+		}
+		files.add(wrapper.file);
+		const fileName = lastName(basename(wrapper.file));
+		probe.add(fileName);
+		if (wrapper.package) continue;
+		const alias = fileName === "index" ? basename(dirname(wrapper.file)) : fileName;
+		if (usable(alias)) names.add(alias);
+	}
+	for (const name of names) probe.add(name);
+	const needles = /* @__PURE__ */ new Set([
+		...entries,
+		...names,
+		...config.extraction.globals
+	]);
+	for (const name of probe) if (!names.has(name)) needles.add("/" + name);
+	const info = {
+		importSources: config.extraction.importSources,
+		root: config.root,
+		entries,
+		names,
+		unresolved,
+		probe,
+		files,
+		needles: [...needles]
+	};
+	infos.set(config, info);
+	return info;
+}
+/**
+* Strings one of which occurs in every module that can hold an extracted call
+* (import sources, wrapper names, globals). A module containing none of them
+* cannot bind vi18n, so the scan skips parsing it, as the plugin's code
+* filter does.
+*/
+function sourceNeedles(config) {
+	return sourceInfo(config).needles;
+}
+/**
+* The specifiers among `imports` (of the module at absolute path `file`)
+* that are vi18n sources. Relative imports are resolved only when their last
+* segment names a wrapper, so a module costs file-system probes only for
+* likely wrapper imports. A wrapper the CLI cannot resolve is matched by name
+* for relative imports too, like alias-form imports (§6 D13).
+*/
+function sourceSpecifiers(imports, file, config) {
+	const info = sourceInfo(config);
+	const out = /* @__PURE__ */ new Set();
+	for (const { specifier } of imports) {
+		if (out.has(specifier)) continue;
+		if (info.entries.has(specifier)) {
+			out.add(specifier);
+			continue;
+		}
+		const name = lastName(specifier);
+		if (!isRelative(specifier)) {
+			if (info.names.has(name)) out.add(specifier);
+		} else if (info.unresolved.has(name)) out.add(specifier);
+		else if (info.probe.has(name)) {
+			const target = probeModule(resolve(dirname(file), specifier));
+			if (target !== null && info.files.has(target)) out.add(specifier);
+		}
+	}
+	return out;
+}
+//#endregion
+export { isIgnored as a, unwrap as c, listImports as d, findMarkers as i, lineColumn as l, sourceSpecifiers as n, markersOf as o, scanModule as r, keyName as s, sourceNeedles as t, locateLiteral as u };