@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/worker-84U6uYB3.js

@@ -0,0 +1,1656 @@
+import { a as diagnosticError, o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { t as createCodec } from "./codec-DuvU2VQy.js";
+import { r as libraryIds } from "./library-D5CWvTQs.js";
+import { c as unwrap, d as listImports, l as lineColumn, n as sourceSpecifiers, r as scanModule, s as keyName, t as sourceNeedles, u as locateLiteral } from "./sources-D19czDSA.js";
+import { createRequire } from "node:module";
+import { dirname, join, sep } from "node:path";
+import { hash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { isMainThread, parentPort, workerData } from "node:worker_threads";
+import MagicString from "magic-string";
+//#region src/core/extract/parser.ts
+/**
+* Parsing for extraction (INTERNALS §2.5.4–§2.5.5). The parser is Oxc as Vite
+* ships it (`parseSync`), so there is no parser dependency of our own (§6 D16)
+* and the CLI and the plugin see the same ESTree. Once raw transfer starts
+* ({@link armRawParsing}, {@link enableRawParsing}), the same binding parses
+* through it (`raw.ts`, §6 D104) when its Oxc version allows: the same tree,
+* faster.
+*/
+let parseSync = null;
+/** The raw-transfer parser, once {@link enableRawParsing} found one usable. */
+let parseRaw = null;
+let rawReady = null;
+function loadParser(filename) {
+	if (parseSync !== null) return parseSync;
+	let mod;
+	try {
+		mod = createRequire(import.meta.url)("vite");
+	} catch (error) {
+		throw diagnosticError({
+			code: "extract-parse-error",
+			severity: "error",
+			message: `Cannot load the parser from "vite" (${error.message}); install vite 8 as a dev dependency`,
+			...filename === void 0 ? {} : { file: filename }
+		});
+	}
+	if (typeof mod.parseSync !== "function") throw diagnosticError({
+		code: "extract-parse-error",
+		severity: "error",
+		message: `The installed "vite" does not export parseSync; install vite 8 or later`,
+		...filename === void 0 ? {} : { file: filename }
+	});
+	parseSync = mod.parseSync;
+	return parseSync;
+}
+/**
+* Names of the platform packages a binding loads from. An owner's other
+* optional dependencies are not where its binding lives, and some load a
+* `.node` file of their own (`fsevents`, which Vite+ declares, on macOS).
+*/
+const PLATFORM_PACKAGE = /^(?:@voidzero-dev\/vite-plus|@rolldown\/binding)-/;
+/**
+* {@link BindingOwner} of the `vite` that `from` resolves, or null when it
+* cannot be told for certain. Only what the owner declares counts: a
+* hoisted `rolldown` or `@oxc-project/types` that belongs to another package
+* (Astro's or Nuxt's Rolldown in the same tree) would vouch for a layout
+* the binding in use does not write. The owner must pin
+* `@oxc-project/types` exactly, and the copy it resolves must be that
+* version.
+*/
+function bindingOwner(from = import.meta.url) {
+	if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) return null;
+	try {
+		let dir = dirname(realpathSync(createRequire(from).resolve("vite/package.json")));
+		let pkg = readPackage(dir);
+		if (pkg.dependencies?.["@oxc-project/types"] === void 0) {
+			if (pkg.dependencies?.rolldown === void 0) return null;
+			dir = dirname(realpathSync(createRequire(join(dir, "package.json")).resolve("rolldown/package.json")));
+			pkg = readPackage(dir);
+		}
+		const pinned = /^=?(\d+\.\d+\.\d+)$/.exec(pkg.dependencies?.["@oxc-project/types"] ?? "")?.[1];
+		if (pinned === void 0) return null;
+		const ownerRequire = createRequire(join(dir, "package.json"));
+		if (ownerRequire("@oxc-project/types/package.json").version !== pinned) return null;
+		const dirs = [dir];
+		for (const name of Object.keys(pkg.optionalDependencies ?? {})) {
+			if (!PLATFORM_PACKAGE.test(name)) continue;
+			try {
+				dirs.push(dirname(realpathSync(ownerRequire.resolve(`${name}/package.json`))));
+			} catch {}
+		}
+		return {
+			dirs,
+			oxcVersion: pinned
+		};
+	} catch {
+		return null;
+	}
+}
+function readPackage(dir) {
+	return JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+}
+/**
+* The native binding of `owner` among the loaded native modules, if it has
+* raw transfer. `vite` exports no handle to it, but loading it put it in
+* the module cache; other bindings sit there too (another Rolldown, the
+* `oxc-parser` devDependency's) and are told apart by where they live, never
+* by load order or file name.
+*/
+function ownBinding(owner, cache = createRequire(import.meta.url).cache) {
+	for (const key in cache) {
+		if (!key.endsWith(".node")) continue;
+		let real;
+		try {
+			real = realpathSync(key);
+		} catch {
+			continue;
+		}
+		if (!owner.dirs.some((dir) => real.startsWith(dir + sep))) continue;
+		const exports = cache[key]?.exports;
+		if (typeof exports?.parseRawSync === "function" && typeof exports.getBufferOffset === "function" && typeof exports.rawTransferSupported === "function") return exports;
+	}
+	return null;
+}
+let parses = 0;
+let rawAfter = Infinity;
+/**
+* Starts raw transfer once {@link RAW_AFTER} (or `after`) modules more have
+* parsed with `parseSync`, without delaying any of them; `after` 0, or
+* `VI18N_RAW_PARSE=1`, starts it now. Idempotent.
+*/
+function armRawParsing(after = 500) {
+	if (rawReady !== null || process.env.VI18N_RAW_PARSE === "0") return;
+	if (process.env.VI18N_RAW_PARSE === "1") after = 0;
+	if (after > 0) rawAfter = Math.min(rawAfter, parses + after);
+	else startRaw();
+}
+function startRaw() {
+	rawReady ??= (async () => {
+		if (process.env.VI18N_RAW_PARSE === "0") return false;
+		try {
+			const sync = loadParser(void 0);
+			const owner = bindingOwner();
+			const binding = owner === null ? null : ownBinding(owner);
+			if (owner === null || binding === null) return false;
+			const raw = await import("./raw-C4Y6vyGY.js");
+			if (!raw.LAYOUT_VERSIONS.has(owner.oxcVersion)) return false;
+			parseRaw = raw.createRawParser(binding, sync);
+			return parseRaw !== null;
+		} catch {
+			return false;
+		}
+	})();
+	return rawReady;
+}
+/**
+* The parser language for a module id, by the extension of its path (query
+* and `\0` prefix ignored). Framework files (`.vue`, `.svelte`, `.astro`,
+* `.mdx`) reach the post pass as plain JS.
+*/
+function langFromId(id) {
+	const query = id.indexOf("?");
+	const end = query === -1 ? id.length : query;
+	const dot = id.lastIndexOf(".", end);
+	if (dot === -1 || id.lastIndexOf("/", end) > dot) return "js";
+	switch (id.slice(dot + 1, end).toLowerCase()) {
+		case "ts":
+		case "mts":
+		case "cts": return "ts";
+		case "tsx": return "tsx";
+		case "jsx": return "jsx";
+		default: return "js";
+	}
+}
+/**
+* Parses `code` as an ES module. Throws a `DiagnosticError`
+* (`extract-parse-error`) on the first syntax error: a partially recovered
+* tree could make the rewriter edit the wrong ranges.
+*/
+function parseModule(code, lang, filename) {
+	if (parseRaw === null && ++parses >= rawAfter) {
+		rawAfter = Infinity;
+		startRaw();
+	}
+	const result = (parseRaw ?? loadParser(filename))(filename ?? `module.${lang}`, code, {
+		lang: lang === "js" ? "jsx" : lang,
+		sourceType: "module",
+		preserveParens: false
+	});
+	const first = result.errors[0];
+	if (first !== void 0) {
+		const offset = first.labels?.[0]?.start;
+		throw diagnosticError({
+			code: "extract-parse-error",
+			severity: "error",
+			message: `Cannot parse${filename === void 0 ? "" : ` ${filename}`}: ${first.message}`,
+			...filename === void 0 ? {} : { file: filename },
+			...offset === void 0 ? {} : lineColumn(code, offset)
+		});
+	}
+	const parsed = {
+		code,
+		lang,
+		program: result.program
+	};
+	if (result.comments !== void 0) parsed.comments = result.comments;
+	return parsed;
+}
+//#endregion
+//#region src/core/extract/entities.ts
+/** HTML entities JSX text may spell; React and Solid decode them the same way. */
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0",
+	ndash: "–",
+	mdash: "—",
+	hellip: "…",
+	lsquo: "‘",
+	rsquo: "’",
+	ldquo: "“",
+	rdquo: "”",
+	copy: "©",
+	reg: "®",
+	trade: "™",
+	middot: "·",
+	times: "×"
+};
+function decodeEntities(text) {
+	return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, name) => {
+		if (name[0] === "#") {
+			const code = name[1] === "x" || name[1] === "X" ? parseInt(name.slice(2), 16) : +name.slice(1);
+			return code <= 1114111 ? String.fromCodePoint(code) : whole;
+		}
+		return Object.hasOwn(ENTITIES, name) ? ENTITIES[name] : whole;
+	});
+}
+//#endregion
+//#region src/core/extract/macro.ts
+/** The local the expansion calls, imported once per expanded module. */
+const MACRO_RICH = "__vi18nRich";
+const IMPORT = `import { rich as ${MACRO_RICH} } from "@menapo/vi18n";`;
+/** The handlers' children parameter. */
+const CHILDREN = "__vi18nChildren";
+const TYPE_KEYS = /* @__PURE__ */ new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"typeArguments",
+	"returnType"
+]);
+/** Local names bound to `T` imported from a vi18n import source. */
+function macroNames(imports, sources) {
+	const names = /* @__PURE__ */ new Set();
+	for (const record of imports) {
+		if (!sources.has(record.specifier)) continue;
+		for (const { local, imported } of record.bindings) if (imported === "T") names.add(local);
+	}
+	return names;
+}
+var MacroError = class extends Error {
+	code;
+	node;
+	constructor(code, message, node) {
+		super(message);
+		this.code = code;
+		this.node = node;
+	}
+};
+/** JSX's whitespace rule (Babel's `cleanJSXElementLiteralChild`, which Solid follows). */
+function cleanText(raw) {
+	const lines = raw.split(/\r\n|\n|\r/);
+	let lastNonEmpty = 0;
+	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.test(lines[i])) lastNonEmpty = i;
+	let out = "";
+	for (let i = 0; i < lines.length; i++) {
+		let line = lines[i].replace(/\t/g, " ");
+		if (i !== 0) line = line.replace(/^ +/, "");
+		if (i !== lines.length - 1) line = line.replace(/ +$/, "");
+		if (line) out += i === lastNonEmpty ? line : line + " ";
+	}
+	return out;
+}
+/** Literal text as ICU source: syntax characters quoted, every apostrophe doubled. */
+function icuText(text) {
+	return text.replace(/'/g, "''").replace(/[{}<>]+/g, (run) => `'${run}'`);
+}
+/** Tag names the compiler accepts (INTERNALS §2.1): an ASCII letter, then name characters. */
+const TAG_NAME = /^[A-Za-z][\w.-]*$/;
+var Expander = class {
+	code;
+	constructor(code) {
+		this.code = code;
+	}
+	/** `<T id? context? maxLength?>children</T>` → the `rich()` call. */
+	expand(element) {
+		const opening = element.openingElement;
+		const descriptor = [];
+		let spread = null;
+		for (const attribute of opening.attributes) {
+			if (attribute.type !== "JSXAttribute") throw new MacroError("extract-non-literal-option", "<T> takes only literal id, context and maxLength attributes and values={…}, not a spread", attribute);
+			const name = keyName(attribute.name, false);
+			const value = attribute.value;
+			if (name === "values" && value?.type === "JSXExpressionContainer") {
+				const expression = value.expression;
+				spread = `...(${this.code.slice(expression.start, expression.end)})`;
+			} else descriptor.push(this.attribute(name, attribute));
+		}
+		const out = {
+			message: "",
+			values: [],
+			tags: /* @__PURE__ */ new Map(),
+			args: /* @__PURE__ */ new Map()
+		};
+		if (spread !== null) out.values.push(spread);
+		this.children(element.children, out);
+		if (out.message.trim() === "") throw new MacroError("extract-dynamic-message", "<T> needs text to translate", element);
+		const message = JSON.stringify(out.message);
+		const key = descriptor.length === 0 ? message : `{ message: ${message}, ${descriptor.join(", ")} }`;
+		const values = out.values.length === 0 ? "" : `, { ${out.values.join(", ")} }`;
+		return `${MACRO_RICH}(${key}${values})`;
+	}
+	attribute(name, attribute) {
+		const value = attribute.value;
+		const inner = value?.type === "JSXExpressionContainer" ? unwrap(value.expression) : value;
+		const invalid = (what) => new MacroError("extract-non-literal-option", `<T> takes only literal id, context and maxLength attributes and values={…}: ${what}`, attribute);
+		if (name === "id" || name === "context") {
+			if (inner?.type !== "Literal" || typeof inner.value !== "string") throw invalid(`${name} is not a string literal`);
+			return `${name}: ${JSON.stringify(inner.value)}`;
+		}
+		if (name === "maxLength") {
+			if (inner?.type !== "Literal" || typeof inner.value !== "number") throw invalid("maxLength is not a number literal");
+			return `maxLength: ${inner.value}`;
+		}
+		throw invalid(`unknown attribute ${name ?? "?"}`);
+	}
+	children(children, out) {
+		for (const child of children) switch (child.type) {
+			case "JSXText":
+				out.message += icuText(cleanText(decodeEntities(this.code.slice(child.start, child.end))));
+				break;
+			case "JSXExpressionContainer":
+				this.expression(child.expression, out);
+				break;
+			case "JSXFragment":
+				this.children(child.children, out);
+				break;
+			case "JSXElement":
+				this.element(child, out);
+				break;
+			default: throw new MacroError("extract-dynamic-message", "<T> children are text, elements, {name} arguments and ICU strings", child);
+		}
+	}
+	/**
+	* `{name}` and `{user.name}` are arguments named by their last identifier,
+	* `{{ count: items.length }}` names one explicitly, and a string literal
+	* is ICU source as written, the way to a plural or a select. Anything else
+	* would hide text from translators.
+	*/
+	expression(expression, out) {
+		if (expression.type === "JSXEmptyExpression") return;
+		const node = unwrap(expression);
+		if (node.type === "Literal" && typeof node.value === "string") {
+			out.message += node.value;
+			return;
+		}
+		if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+			out.message += node.quasis[0].value.cooked;
+			return;
+		}
+		let name = null;
+		let value = node;
+		if (node.type === "Identifier") name = node.name;
+		else if (node.type === "MemberExpression" && node.computed !== true) name = keyName(node.property, false);
+		else if (node.type === "ObjectExpression") {
+			const properties = node.properties;
+			const only = properties[0];
+			if (properties.length === 1 && only?.type === "Property" && only.computed !== true) {
+				name = keyName(only.key, false);
+				value = only.value;
+			}
+		}
+		if (name === null || !/^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(name)) throw new MacroError("extract-dynamic-message", `<T> takes {name}, {obj.name} or {{ name: value }} as an argument, not {${this.code.slice(node.start, node.end)}}`, node);
+		const source = this.code.slice(value.start, value.end);
+		const previous = out.args.get(name);
+		if (previous !== void 0 && previous !== source) throw new MacroError("extract-dynamic-message", `<T> argument {${name}} stands for two values (${previous}, ${source}); name one with {{ other: … }}`, node);
+		if (previous === void 0) {
+			out.args.set(name, source);
+			out.values.push(source === name ? name : `${JSON.stringify(name)}: ${source}`);
+		}
+		out.message += `{${name}}`;
+	}
+	/** A nested element: a tag named after it, its markup moved into the handler. */
+	element(element, out) {
+		const opening = element.openingElement;
+		const closing = element.closingElement;
+		const base = this.tagName(opening.name);
+		const children = element.children;
+		const standalone = closing === null || children.length === 0;
+		const open = this.code.slice(opening.start, opening.end);
+		const handler = standalone ? `() => ${this.code.slice(element.start, element.end)}` : `(${CHILDREN}) => ${open}{${CHILDREN}}${this.code.slice(closing.start, closing.end)}`;
+		let name = base;
+		for (let n = 2; out.tags.has(name) && out.tags.get(name) !== handler; n++) name = base + n;
+		if (!out.tags.has(name)) {
+			out.tags.set(name, handler);
+			out.values.push(`${JSON.stringify(name)}: ${handler}`);
+		}
+		if (standalone) {
+			out.message += `<${name}/>`;
+			return;
+		}
+		out.message += `<${name}>`;
+		this.children(children, out);
+		out.message += `</${name}>`;
+	}
+	tagName(name) {
+		const text = name.type === "JSXIdentifier" ? name.name : name.type === "JSXMemberExpression" ? this.code.slice(name.start, name.end) : "";
+		if (!TAG_NAME.test(text)) throw new MacroError("extract-dynamic-message", `<T> cannot name a tag after <${this.code.slice(name.start, name.end)}>: wrap it in an element or component with a plain name`, name);
+		return text;
+	}
+};
+/**
+* Expands every `<T>` whose name is in `options.names` (a `<T>` inside
+* another is a build error). Returns the diagnostics; the sink holds the
+* edits, and the module gets one `rich` import when anything expanded.
+*/
+function expandMacros(parsed, sink, options) {
+	const code = parsed.code;
+	const program = parsed.program;
+	const expander = new Expander(code);
+	const diagnostics = [];
+	let edited = false;
+	const isMacro = (node) => {
+		const name = node.openingElement.name;
+		return name.type === "JSXIdentifier" && options.names.has(name.name);
+	};
+	const stack = [{
+		node: program,
+		child: false
+	}];
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+		const { node, child } = next;
+		if (node.type === "JSXElement" && isMacro(node)) {
+			try {
+				const nested = findNested(node, isMacro);
+				if (nested !== null) throw new MacroError("extract-dynamic-message", "<T> cannot contain another <T>", nested);
+				let call = expander.expand(node);
+				if (options.keepLines === true) call += "\n".repeat(code.slice(node.start, node.end).split("\n").length - 1);
+				sink.overwrite(node.start, node.end, child ? `{${call}}` : `<>{${call}}</>`);
+				edited = true;
+			} catch (error) {
+				if (!(error instanceof MacroError)) throw error;
+				diagnostics.push({
+					code: error.code,
+					severity: "error",
+					message: error.message,
+					file: options.refFile,
+					...lineColumn(code, error.node.start)
+				});
+			}
+			continue;
+		}
+		const jsx = node.type === "JSXElement" || node.type === "JSXFragment";
+		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;
+			const isChildren = jsx && key === "children";
+			if (Array.isArray(value)) for (let i = value.length - 1; i >= 0; i--) {
+				const item = value[i];
+				if (item !== null && typeof item?.type === "string") stack.push({
+					node: item,
+					child: isChildren
+				});
+			}
+			else if (typeof value.type === "string") stack.push({
+				node: value,
+				child: false
+			});
+		}
+	}
+	if (edited) sink.appendLeft(afterDirectives(program), IMPORT);
+	return {
+		edited,
+		diagnostics
+	};
+}
+/** A `<T>` inside `element`'s children, at any depth. */
+function findNested(element, isMacro) {
+	const stack = [...element.children];
+	for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+		if (node.type === "JSXElement" && isMacro(node)) return node;
+		if (node.type === "JSXElement" || node.type === "JSXFragment") stack.push(...node.children);
+	}
+	return null;
+}
+/** Where an import may go: after `"use client"` and other directives. */
+function afterDirectives(program) {
+	let at = 0;
+	for (const statement of program.body) {
+		if (statement.type !== "ExpressionStatement" || typeof statement.directive !== "string") break;
+		at = statement.end;
+	}
+	return at;
+}
+//#endregion
+//#region src/core/extract/sfc-parse.ts
+/** Thrown inside a walk for a shape parse-only extraction does not cover. */
+var Unproven = class extends Error {};
+function unproven(reason) {
+	throw new Unproven(reason);
+}
+function pick$1(module, name) {
+	return module[name] ?? module.default?.[name];
+}
+/**
+* An expression from the template on lines of its own, so a trailing `//`
+* comment cannot swallow what follows.
+*/
+function expr(text) {
+	return "(\n" + text + "\n)";
+}
+/** `code` with `ranges` replaced by spaces, line breaks kept. */
+function blank(code, ranges) {
+	if (ranges.length === 0) return code;
+	const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+	let out = "";
+	let at = 0;
+	for (const [start, end] of sorted) {
+		if (start < at) continue;
+		out += code.slice(at, start) + code.slice(start, end).replace(/[^\n]/g, " ");
+		at = end;
+	}
+	return out + code.slice(at);
+}
+/** Top-level binding names of a program (imports and declarations). */
+function topLevelNames(program, into) {
+	const pattern = (node) => {
+		if (node === null || node === void 0) return;
+		switch (node.type) {
+			case "Identifier":
+				into.add(node.name);
+				return;
+			case "ObjectPattern":
+				for (const property of node.properties) pattern(property.type === "RestElement" ? property.argument : property.value);
+				return;
+			case "ArrayPattern":
+				for (const element of node.elements) pattern(element);
+				return;
+			case "AssignmentPattern":
+				pattern(node.left);
+				return;
+			case "RestElement":
+				pattern(node.argument);
+				return;
+		}
+	};
+	for (let statement of program.body) {
+		if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") && statement.declaration !== null && statement.declaration !== void 0) statement = statement.declaration;
+		switch (statement.type) {
+			case "ImportDeclaration":
+				for (const specifier of statement.specifiers) into.add(specifier.local.name);
+				break;
+			case "VariableDeclaration":
+				for (const declarator of statement.declarations) pattern(declarator.id);
+				break;
+			case "FunctionDeclaration":
+			case "ClassDeclaration":
+			case "TSEnumDeclaration": if (statement.id !== null && statement.id !== void 0) into.add(statement.id.name);
+		}
+	}
+}
+/** `@vue/compiler-core` NodeTypes and ElementTypes of the raw template AST. */
+const ELEMENT = 1;
+const TEXT = 2;
+const COMMENT = 3;
+const INTERPOLATION = 5;
+const ATTRIBUTE = 6;
+const DIRECTIVE = 7;
+const COMPONENT = 1;
+/** The setup macros whose arguments Vue moves into the component options, at module level. */
+const VUE_MACROS = /* @__PURE__ */ new Set([
+	"defineProps",
+	"withDefaults",
+	"defineEmits",
+	"defineOptions",
+	"defineModel"
+]);
+/** Components Vue resolves before setup bindings (compiler-core `resolveComponentType`). */
+const VUE_BUILT_INS = /* @__PURE__ */ new Set([
+	"component",
+	"Component",
+	"teleport",
+	"Teleport",
+	"suspense",
+	"Suspense",
+	"keep-alive",
+	"KeepAlive",
+	"base-transition",
+	"BaseTransition",
+	"transition",
+	"Transition",
+	"transition-group",
+	"TransitionGroup"
+]);
+/** `v-on` values Vue passes as they are instead of wrapping them in `$event => (…)`. */
+const VUE_FN_EXPRESSION = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+/** `v-for`'s `alias in source`, as compiler-core splits it. */
+const VUE_FOR = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
+const camelize = (name) => name.replace(/-(\w)/g, (_all, c) => c.toUpperCase());
+const capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+function modifierNames(prop) {
+	return (prop.modifiers ?? []).map((m) => typeof m === "string" ? m : m.content);
+}
+var VueTemplate = class {
+	out = [];
+	/**
+	* `bindings` holds the top-level names of `<script setup>` mode, where a
+	* component tag naming one is that binding (`_createVNode(T, …)`); null
+	* outside it, where Vue resolves components by name at runtime.
+	*/
+	bindings;
+	constructor(bindings) {
+		this.bindings = bindings;
+	}
+	children(nodes) {
+		for (const node of nodes ?? []) this.node(node);
+	}
+	node(node) {
+		switch (node.type) {
+			case TEXT:
+			case COMMENT: return;
+			case INTERPOLATION:
+				this.out.push(expr(node.content.content) + ";");
+				return;
+			case ELEMENT:
+				this.element(node);
+				return;
+			default: unproven(`vue-node-${node.type}`);
+		}
+	}
+	/** The binding a component tag resolves to in `<script setup>` mode, as compiler-core finds it. */
+	componentBinding(tag) {
+		if (this.bindings === null || VUE_BUILT_INS.has(tag)) return null;
+		for (const name of [
+			tag,
+			camelize(tag),
+			capitalize(camelize(tag))
+		]) if (this.bindings.has(name)) return name;
+		return null;
+	}
+	element(node) {
+		const props = node.props ?? [];
+		let closers = 0;
+		for (const prop of props) if (prop.type === DIRECTIVE && (prop.name === "if" || prop.name === "else-if")) {
+			if (prop.exp !== void 0) this.out.push(expr(prop.exp.content) + ";");
+		}
+		const loop = props.find((p) => p.type === DIRECTIVE && p.name === "for");
+		if (loop !== void 0) {
+			const match = VUE_FOR.exec(loop.exp?.content ?? "");
+			if (match === null) unproven("vue-for");
+			const alias = match[1].trim().replace(/^\(|\)$/g, "");
+			this.out.push(expr(match[2].trim()) + ";");
+			this.out.push(`((${alias}) => {`);
+			closers++;
+		}
+		const component = node.tagType === COMPONENT ? this.componentBinding(node.tag) : null;
+		if (this.bindings === null && node.tagType === COMPONENT && hasProp(props, "message")) unproven("vue-options-component");
+		const entries = [];
+		const statements = [];
+		const merged = [];
+		let slot;
+		for (const prop of props) {
+			if (prop.type === ATTRIBUTE) {
+				if (component !== null) entries.push(`${JSON.stringify(prop.name)}: ${JSON.stringify(prop.value?.content ?? "")}`);
+				continue;
+			}
+			if (prop.type !== DIRECTIVE) unproven(`vue-prop-${prop.type}`);
+			const exp = prop.exp?.content;
+			const arg = prop.arg;
+			const dynamic = arg !== void 0 && arg.isStatic === false;
+			if (dynamic) statements.push(expr(arg.content) + ";");
+			switch (prop.name) {
+				case "if":
+				case "else-if":
+				case "else":
+				case "for": break;
+				case "slot":
+					slot = prop;
+					break;
+				case "bind": {
+					if (arg === void 0) {
+						if (exp !== void 0) merged.push(expr(exp));
+						break;
+					}
+					if (dynamic) {
+						merged.push(`{ [${expr(arg.content)}]: ${exp === void 0 ? "0" : expr(exp)} }`);
+						break;
+					}
+					const modifiers = modifierNames(prop);
+					let key = modifiers.includes("camel") ? camelize(arg.content) : arg.content;
+					if (modifiers.includes("prop")) key = "." + key;
+					else if (modifiers.includes("attr")) key = "^" + key;
+					entries.push(`${JSON.stringify(key)}: ${exp === void 0 ? camelize(arg.content) : expr(exp)}`);
+					break;
+				}
+				case "on": {
+					const handler = exp === void 0 ? "null" : VUE_FN_EXPRESSION.test(exp) || /^\s*[\w$]+(?:\s*\.\s*[\w$]+)*\s*$/.test(exp) ? expr(exp) : `($event) => {\n${exp}\n}`;
+					if (arg === void 0 || dynamic) merged.push(handler);
+					else entries.push(`${JSON.stringify("on:" + arg.content)}: ${handler}`);
+					break;
+				}
+				case "model":
+					if (exp !== void 0) {
+						const key = arg === void 0 || dynamic ? "modelValue" : arg.content;
+						if (dynamic) merged.push(expr(exp));
+						else entries.push(`${JSON.stringify(key)}: ${expr(exp)}`);
+					}
+					break;
+				case "html":
+					if (exp !== void 0) entries.push(`innerHTML: ${expr(exp)}`);
+					break;
+				case "text":
+					if (exp !== void 0) entries.push(`textContent: ${expr(exp)}`);
+					break;
+				default: if (exp !== void 0) statements.push(expr(exp) + ";");
+			}
+		}
+		let props_ = `{${entries.length === 0 ? "" : "\n" + entries.join(",\n") + "\n"}}`;
+		if (merged.length > 0) props_ = `__vi18n_merge(${props_}, ${merged.join(", ")})`;
+		this.out.push(component === null ? `__vi18n_node(${props_});` : `__vi18n_vnode(${component}, ${props_});`);
+		for (const statement of statements) this.out.push(statement);
+		if (slot?.exp !== void 0) {
+			this.out.push(`((${slot.exp.content}) => {`);
+			closers++;
+		}
+		this.children(node.children);
+		for (let i = 0; i < closers; i++) this.out.push("});");
+	}
+};
+function hasProp(props, name) {
+	return props.some((p) => p.type === ATTRIBUTE ? p.name === name : p.arg !== void 0 && (p.arg.isStatic === false || camelize(p.arg.content) === name));
+}
+function vueLang(lang) {
+	return lang === "ts" || lang === "tsx" || lang === "jsx" ? lang : "js";
+}
+/**
+* Script setup statements that Vue's compileScript moves: imports to module
+* scope, and the arguments of the options macros into the component options
+* (module scope too, so a call directly in them is at module scope there).
+*/
+function setupLayout(setup, lang, file) {
+	let program;
+	try {
+		program = parseModule(setup, lang, file).program;
+	} catch {
+		unproven("script-syntax");
+	}
+	const imports = [];
+	const hoisted = [];
+	const blanks = [];
+	const macro = (node) => {
+		if (node === null || node === void 0) return;
+		let call = node;
+		while (call.type === "TSAsExpression" || call.type === "TSSatisfiesExpression" || call.type === "TSNonNullExpression") call = call.expression;
+		if (call.type !== "CallExpression") return;
+		const callee = call.callee;
+		if (callee.type !== "Identifier" || !VUE_MACROS.has(callee.name)) return;
+		const args = call.arguments;
+		if (callee.name === "withDefaults") macro(args[0]);
+		const moved = callee.name === "withDefaults" ? args.slice(1) : args;
+		if (moved.length === 0) return;
+		const start = moved[0].start;
+		const end = moved[moved.length - 1].end;
+		hoisted.push(expr(setup.slice(start, end)) + ";");
+		blanks.push([start, end]);
+	};
+	for (const statement of program.body) switch (statement.type) {
+		case "ImportDeclaration":
+			imports.push(setup.slice(statement.start, statement.end));
+			blanks.push([statement.start, statement.end]);
+			break;
+		case "ExportNamedDeclaration":
+		case "ExportDefaultDeclaration":
+		case "ExportAllDeclaration":
+			unproven("vue-setup-export");
+			break;
+		case "ExpressionStatement":
+			macro(statement.expression);
+			break;
+		case "VariableDeclaration": for (const declarator of statement.declarations) {
+			const init = declarator.init;
+			const id = declarator.id;
+			if (init !== null && id.type === "ObjectPattern" && /\b(?:defineProps|withDefaults)\s*[<(]/.test(setup.slice(init.start, init.end)) && id.properties.some((p) => p.value?.type === "AssignmentPattern")) unproven("vue-props-destructure-default");
+			macro(init);
+		}
+	}
+	return {
+		imports,
+		hoisted,
+		body: blank(setup, blanks),
+		program
+	};
+}
+/**
+* The module parse-only extraction scans for a `.vue` file: `<script>` as it
+* is, `<script setup>` imports and macro arguments at module level, its
+* statements inside a setup function that ends with the template's
+* expressions (the inline template of a production build), or the template
+* in a render function of its own.
+*/
+function vueParseOnly(compiler, file, code) {
+	const parse = pick$1(compiler, "parse");
+	if (parse === void 0) return { fallback: "vue-api" };
+	try {
+		const { descriptor, errors } = parse(code, {
+			filename: file,
+			sourceMap: false,
+			templateParseOptions: {}
+		});
+		if (errors.length > 0) return { fallback: "vue-parse-error" };
+		const { script, scriptSetup, template } = descriptor;
+		if (script?.src !== void 0 || scriptSetup?.src !== void 0 || template?.src !== void 0) return { fallback: "vue-src" };
+		if (template !== null && template.lang !== void 0 && template.lang !== "html") return { fallback: "vue-template-lang" };
+		if (template !== null && template.ast === void 0) return { fallback: "vue-api" };
+		if (template?.content.includes("vi18n-") === true) return { fallback: "template-marker" };
+		if (script !== null && scriptSetup !== null && vueLang(script.lang) !== vueLang(scriptSetup.lang)) return { fallback: "vue-script-lang" };
+		const lang = vueLang(scriptSetup?.lang ?? script?.lang);
+		const parts = [];
+		if (script !== null) parts.push(script.content);
+		if (scriptSetup === null) {
+			const walk = new VueTemplate(null);
+			walk.children(template?.ast?.children);
+			parts.push("function __vi18n_render() {", ...walk.out, "}");
+			return {
+				code: parts.join("\n"),
+				lang
+			};
+		}
+		const layout = setupLayout(scriptSetup.content, lang, file);
+		const bindings = /* @__PURE__ */ new Set();
+		topLevelNames(layout.program, bindings);
+		if (script !== null) try {
+			topLevelNames(parseModule(script.content, lang, file).program, bindings);
+		} catch {
+			return { fallback: "script-syntax" };
+		}
+		const walk = new VueTemplate(bindings);
+		walk.children(template?.ast?.children);
+		parts.push(...layout.imports, ...layout.hoisted);
+		parts.push("async function __vi18n_setup() {", layout.body);
+		parts.push("function __vi18n_render() {", ...walk.out, "}", "}");
+		return {
+			code: parts.join("\n"),
+			lang
+		};
+	} catch (error) {
+		if (error instanceof Unproven) return { fallback: error.message };
+		return { fallback: "vue-parse-error" };
+	}
+}
+/** Elements whose attributes and children are plain template code. */
+const SVELTE_ELEMENTS = /* @__PURE__ */ new Set([
+	"RegularElement",
+	"SvelteElement",
+	"SvelteComponent",
+	"SvelteSelf",
+	"SvelteHead",
+	"SvelteBody",
+	"SvelteWindow",
+	"SvelteDocument",
+	"SvelteFragment",
+	"SvelteBoundary",
+	"SlotElement",
+	"TitleElement"
+]);
+/**
+* Svelte 5's runes; any other `$name` reads a store (`$.store_get(…)` in
+* compiled code, which the scanner cannot follow) or is a compile error.
+*/
+const SVELTE_RUNES = /* @__PURE__ */ new Set([
+	"$state",
+	"$derived",
+	"$effect",
+	"$props",
+	"$bindable",
+	"$inspect",
+	"$host"
+]);
+/** True when an identifier anywhere in `root` subscribes to a store. */
+function readsStore(root) {
+	const stack = [root];
+	const seen = /* @__PURE__ */ new WeakSet();
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (typeof node !== "object" || node === null || seen.has(node)) continue;
+		seen.add(node);
+		if (Array.isArray(node)) {
+			for (const item of node) stack.push(item);
+			continue;
+		}
+		const record = node;
+		if (record.type === "Identifier") {
+			const name = record.name;
+			if (/^\$[A-Za-z_]/.test(name) && !SVELTE_RUNES.has(name)) return true;
+		}
+		for (const key in record) if (key !== "loc" && key !== "metadata") stack.push(record[key]);
+	}
+	return false;
+}
+/** Text for a template literal: the characters it treats specially, escaped. */
+function templateText(text) {
+	return text.replace(/[\\`]|\$\{/g, (c) => "\\" + c);
+}
+var SvelteTemplate = class {
+	out = [];
+	code;
+	constructor(code) {
+		this.code = code;
+	}
+	slice(node) {
+		return this.code.slice(node.start, node.end);
+	}
+	expression(node) {
+		return expr(this.slice(node));
+	}
+	fragment(fragment) {
+		for (const node of fragment?.nodes ?? []) this.node(node);
+	}
+	node(node) {
+		switch (node.type) {
+			case "Text":
+			case "Comment":
+			case "DebugTag": return;
+			case "ExpressionTag":
+			case "RenderTag":
+				this.out.push(this.expression(node.expression) + ";");
+				return;
+			case "ConstTag": {
+				const declarator = node.declaration.declarations[0];
+				this.out.push(`const ${this.slice(declarator.id)} = __vi18n_derived(() => ${this.expression(declarator.init)});`);
+				return;
+			}
+			case "HtmlTag":
+				this.out.push(`$.html(null, () => ${this.expression(node.expression)});`);
+				return;
+			case "IfBlock":
+				this.out.push(this.expression(node.test) + ";");
+				this.fragment(node.consequent);
+				this.fragment(node.alternate);
+				return;
+			case "EachBlock": {
+				this.out.push(this.expression(node.expression) + ";");
+				const params = [];
+				const context = node.context;
+				params.push(context === null ? "__vi18n_item" : this.slice(context));
+				if (typeof node.index === "string") params.push(node.index);
+				this.out.push(`((${params.join(", ")}) => {`);
+				if (node.key !== null && node.key !== void 0) this.out.push(this.expression(node.key) + ";");
+				this.fragment(node.body);
+				this.out.push("});");
+				this.fragment(node.fallback);
+				return;
+			}
+			case "AwaitBlock":
+				this.out.push(this.expression(node.expression) + ";");
+				this.fragment(node.pending);
+				this.scoped(node.value, node.then);
+				this.scoped(node.error, node.catch);
+				return;
+			case "KeyBlock":
+				this.out.push(this.expression(node.expression) + ";");
+				this.fragment(node.fragment);
+				return;
+			case "SnippetBlock": {
+				const parameters = node.parameters;
+				const params = parameters.length === 0 ? "" : this.slice({
+					start: parameters[0].start,
+					end: parameters[parameters.length - 1].end
+				});
+				const name = node.expression.name;
+				this.out.push(`function ${name}(${params}) {`);
+				this.fragment(node.body);
+				this.out.push("}");
+				return;
+			}
+			case "Component":
+				this.component(node);
+				return;
+			default:
+				if (!SVELTE_ELEMENTS.has(node.type)) unproven(`svelte-node-${node.type}`);
+				if (node.type === "SvelteElement") this.out.push(this.expression(node.tag) + ";");
+				if (node.type === "SvelteComponent") this.out.push(this.expression(node.expression) + ";");
+				for (const attribute of node.attributes) this.attribute(attribute);
+				this.fragment(node.fragment);
+		}
+	}
+	scoped(pattern, body) {
+		if (body === null) return;
+		this.out.push(`((${pattern === null ? "" : this.slice(pattern)}) => {`);
+		this.fragment(body);
+		this.out.push("});");
+	}
+	/** An attribute's expressions, beside the element. */
+	attribute(attribute) {
+		switch (attribute.type) {
+			case "Attribute": {
+				const value = attribute.value;
+				if (value === true) return;
+				for (const part of Array.isArray(value) ? value : [value]) if (part.type === "ExpressionTag") this.out.push(this.expression(part.expression) + ";");
+				return;
+			}
+			case "StyleDirective": {
+				const value = attribute.value;
+				if (value === true) return;
+				for (const part of Array.isArray(value) ? value : [value]) if (part.type === "ExpressionTag") this.out.push(this.expression(part.expression) + ";");
+				return;
+			}
+			case "SpreadAttribute":
+			case "OnDirective":
+			case "BindDirective":
+			case "ClassDirective":
+			case "TransitionDirective":
+			case "AnimateDirective":
+			case "UseDirective":
+			case "AttachTag":
+				if (attribute.expression !== null && attribute.expression !== void 0) this.out.push(this.expression(attribute.expression) + ";");
+				return;
+			default: unproven(`svelte-attribute-${attribute.type}`);
+		}
+	}
+	/** `T(anchor, { props })`, as Svelte calls a component it imports. */
+	component(node) {
+		const entries = [];
+		const merged = [];
+		const statements = [];
+		for (const attribute of node.attributes) {
+			const name = attribute.name;
+			switch (attribute.type) {
+				case "Attribute": {
+					const value = attribute.value;
+					let text;
+					if (value === true) text = "true";
+					else {
+						const parts = Array.isArray(value) ? value : [value];
+						if (parts.length === 1 && parts[0]?.type === "ExpressionTag") text = this.expression(parts[0].expression);
+						else if (parts.every((part) => part.type === "Text")) text = JSON.stringify(parts.map((part) => part.data).join(""));
+						else text = "`" + parts.map((part) => part.type === "Text" ? templateText(part.data) : "${" + this.slice(part.expression) + "}").join("") + "`";
+					}
+					entries.push(`${JSON.stringify(name)}: ${text}`);
+					break;
+				}
+				case "BindDirective":
+					if (name === "this") statements.push(this.expression(attribute.expression) + ";");
+					else entries.push(`${JSON.stringify(name)}: ${this.expression(attribute.expression)}`);
+					break;
+				case "SpreadAttribute":
+					merged.push(this.expression(attribute.expression));
+					break;
+				case "OnDirective":
+				case "AttachTag":
+					if (attribute.expression !== null && attribute.expression !== void 0) statements.push(this.expression(attribute.expression) + ";");
+					break;
+				default: unproven(`svelte-attribute-${attribute.type}`);
+			}
+		}
+		let props = `{${entries.length === 0 ? "" : "\n" + entries.join(",\n") + "\n"}}`;
+		if (merged.length > 0) props = `__vi18n_merge(${props}, ${merged.join(", ")})`;
+		const name = node.name;
+		if (!/^[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*$/u.test(name)) unproven("svelte-component-name");
+		this.out.push(`${name}(null, ${props});`);
+		for (const statement of statements) this.out.push(statement);
+		this.fragment(node.fragment);
+	}
+};
+function isTs(code, script) {
+	const open = code.slice(script.start, script.content.start);
+	return /\blang\s*=\s*["']?(?:ts|typescript)\b/.test(open);
+}
+/**
+* A script block's code with what Svelte's compiler changes for the scan
+* undone: imports out (they are module statements), `export` keywords off
+* (component exports and legacy props stay declarations), and a `const`
+* holding `$state(text)` read as the text, which is how Svelte compiles a
+* state that can never be reassigned.
+*/
+function svelteScript(code, script, hoistImports) {
+	const program = script.content;
+	const base = program.start;
+	const text = code.slice(program.start, program.end);
+	const imports = [];
+	const blanks = [];
+	for (const statement of program.body) {
+		if (statement.type === "ImportDeclaration" && hoistImports) {
+			imports.push(code.slice(statement.start, statement.end));
+			blanks.push([statement.start - base, statement.end - base]);
+		} else if (statement.type === "ExportNamedDeclaration" && hoistImports) {
+			const declaration = statement.declaration;
+			if (declaration === null) blanks.push([statement.start - base, statement.end - base]);
+			else blanks.push([statement.start - base, declaration.start - base]);
+		} else if (statement.type === "ExportDefaultDeclaration" || statement.type === "ExportAllDeclaration") {
+			if (hoistImports) unproven("svelte-export");
+		}
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration ?? statement : statement;
+		if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
+		for (const declarator of declaration.declarations) {
+			const init = declarator.init;
+			if (init?.type !== "CallExpression" || init.arguments.length !== 1) continue;
+			const callee = code.slice(init.callee.start, init.callee.end);
+			if (callee === "$state" || callee === "$state.raw") blanks.push([init.callee.start - base, init.callee.end - base]);
+		}
+	}
+	return {
+		imports,
+		body: blank(text, blanks)
+	};
+}
+/**
+* The module parse-only extraction scans for a `.svelte` file (Svelte 5):
+* `<script module>` at module level, instance imports at module level and
+* the rest of the instance script inside a component function that ends
+* with the template's expressions.
+*/
+function svelteParseOnly(compiler, file, code) {
+	const parse = pick$1(compiler, "parse");
+	const version = pick$1(compiler, "VERSION") ?? "5";
+	if (parse === void 0 || Number.parseInt(version, 10) < 5) return { fallback: "svelte-api" };
+	try {
+		let root;
+		try {
+			root = parse(code, {
+				modern: true,
+				filename: file
+			});
+		} catch {
+			return { fallback: "svelte-parse-error" };
+		}
+		const module = root.module ?? null;
+		const scripts = [module, root.instance ?? null].filter((s) => s !== null);
+		let template = code;
+		for (const script of scripts) template = template.slice(0, script.start) + " ".repeat(script.end - script.start) + template.slice(script.end);
+		if (template.includes("vi18n-")) return { fallback: "template-marker" };
+		if (readsStore([root.fragment, ...scripts])) return { fallback: "svelte-store" };
+		const lang = scripts.some((script) => isTs(code, script)) ? "ts" : "js";
+		const parts = [];
+		if (module !== null) parts.push(svelteScript(code, module, false).body);
+		const instance = root.instance ? svelteScript(code, root.instance, true) : null;
+		const walk = new SvelteTemplate(code);
+		walk.fragment(root.fragment);
+		if (instance !== null) parts.push(...instance.imports);
+		parts.push("function __vi18n_component() {");
+		if (instance !== null) parts.push(instance.body);
+		parts.push(...walk.out, "}");
+		return {
+			code: parts.join("\n"),
+			lang
+		};
+	} catch (error) {
+		if (error instanceof Unproven) return { fallback: error.message };
+		return { fallback: "svelte-parse-error" };
+	}
+}
+//#endregion
+//#region src/core/extract/sfc.ts
+/**
+* Framework files for the CLI scan (INTERNALS §2.5.6): `.vue`, `.svelte`,
+* `.astro` and `.mdx` are compiled with the project's own compilers, so the
+* scanner sees the call shapes the plugin sees after the framework plugins
+* (`_unref(t)(…)`, `$.html(…, () => t(…))`, `$$render`…). Compilers are
+* resolved from the file being compiled and imported on first use: a project
+* without Svelte never loads it, and vi18n depends on none of them.
+*/
+/**
+* Where each compiler may be found, in order: the package the project
+* installs directly, else the framework package that depends on it (pnpm
+* only exposes direct dependencies, and most Vue apps depend on `vue`, which
+* re-exports its compiler as `vue/compiler-sfc`).
+*/
+const COMPILERS = {
+	vue: {
+		name: "Vue",
+		label: "@vue/compiler-sfc (or vue)",
+		candidates: ["@vue/compiler-sfc", "vue/compiler-sfc"]
+	},
+	svelte: {
+		name: "Svelte",
+		label: "svelte",
+		candidates: ["svelte/compiler"]
+	},
+	astro: {
+		name: "Astro",
+		label: "@astrojs/compiler (or astro)",
+		candidates: [
+			"@astrojs/compiler",
+			["astro", "@astrojs/compiler"],
+			"@astrojs/compiler-rs",
+			["astro", "@astrojs/compiler-rs"]
+		]
+	},
+	mdx: {
+		name: "MDX",
+		label: "@mdx-js/mdx",
+		candidates: [
+			"@mdx-js/mdx",
+			["@mdx-js/rollup", "@mdx-js/mdx"],
+			["@astrojs/mdx", "@mdx-js/mdx"]
+		]
+	}
+};
+/** The SFC kind of a file by extension, or null for files the scanner parses directly. */
+function sfcKind(file) {
+	const dot = file.lastIndexOf(".");
+	switch (dot === -1 ? "" : file.slice(dot + 1)) {
+		case "vue": return "vue";
+		case "svelte": return "svelte";
+		case "astro": return "astro";
+		case "mdx": return "mdx";
+		default: return null;
+	}
+}
+/**
+* Resolved compiler path per directory and kind; loaded modules per path.
+* Only hits are kept: a long-lived process (`--watch`, the dev server's
+* background scan) must find a compiler installed after it asked.
+*/
+const resolved = /* @__PURE__ */ new Map();
+const loaded = /* @__PURE__ */ new Map();
+function resolveFrom(from, candidate) {
+	try {
+		if (typeof candidate === "string") return createRequire(from).resolve(candidate);
+		const host = createRequire(from).resolve(candidate[0] + "/package.json");
+		return createRequire(host).resolve(candidate[1]);
+	} catch {
+		return null;
+	}
+}
+async function loadCompiler(kind, file) {
+	const key = kind + "\0" + dirname(file);
+	let path = resolved.get(key) ?? null;
+	if (path === null) {
+		for (const candidate of COMPILERS[kind].candidates) {
+			path = resolveFrom(file, candidate);
+			if (path !== null) break;
+		}
+		if (path === null) return null;
+		resolved.set(key, path);
+	}
+	let module = loaded.get(path);
+	if (module === void 0) {
+		module = import(pathToFileURL(path).href);
+		loaded.set(path, module);
+	}
+	return module;
+}
+/** A named export of a compiler loaded through `import()`, ESM or CommonJS. */
+function pick(module, name) {
+	return module[name] ?? module.default?.[name];
+}
+function compileError(file, detail) {
+	const message = typeof detail === "string" ? detail : detail instanceof Error || typeof detail === "object" && detail !== null && "message" in detail ? String(detail.message) : String(detail);
+	return diagnosticError({
+		code: "extract-parse-error",
+		severity: "error",
+		message: `Cannot compile ${file}: ${message.split("\n")[0]}`,
+		file
+	});
+}
+function missingCompiler(kind, file) {
+	return diagnosticError({
+		code: "extract-missing-compiler",
+		severity: "error",
+		message: `No ${COMPILERS[kind].name} compiler found to extract .${kind} files; install ${COMPILERS[kind].label} in the project`,
+		file
+	});
+}
+function scriptLang(lang) {
+	return lang === "ts" || lang === "tsx" || lang === "jsx" ? lang : "js";
+}
+/**
+* File access for type-based `defineProps<…>()` that imports its types:
+* compiler-sfc resolves them through this or a registered TypeScript.
+*/
+const VUE_FS = {
+	fileExists: (file) => statSync(file, { throwIfNoEntry: false })?.isFile() === true,
+	readFile: (file) => {
+		try {
+			return readFileSync(file, "utf8");
+		} catch {
+			return;
+		}
+	}
+};
+const tsRegistered = /* @__PURE__ */ new WeakSet();
+/**
+* Lets compiler-sfc resolve types imported from packages, as plugin-vue does,
+* when the project has a TypeScript with a JS API (TypeScript 7 has none, and
+* then only relative type imports resolve).
+*/
+function registerTypeScript(compiler, file) {
+	if (tsRegistered.has(compiler)) return;
+	tsRegistered.add(compiler);
+	const register = pick(compiler, "registerTS");
+	if (register === void 0) return;
+	try {
+		const ts = createRequire(file)("typescript");
+		if (ts.sys !== void 0) register(() => ts);
+	} catch {}
+}
+function compileVue(compiler, file, code) {
+	const parse = pick(compiler, "parse");
+	const compileScript = pick(compiler, "compileScript");
+	const compileTemplate = pick(compiler, "compileTemplate");
+	if (parse === void 0 || compileScript === void 0 || compileTemplate === void 0) throw compileError(file, "the installed Vue compiler does not export parse/compileScript/compileTemplate");
+	const { descriptor, errors } = parse(code, {
+		filename: file,
+		sourceMap: false
+	});
+	if (errors.length > 0) throw compileError(file, errors[0]);
+	registerTypeScript(compiler, file);
+	const id = hash("sha256", file, "hex").slice(0, 8);
+	if (descriptor.scriptSetup !== null) {
+		const script = compileScript(descriptor, {
+			id,
+			inlineTemplate: true,
+			sourceMap: false,
+			fs: VUE_FS
+		});
+		return [{
+			code: script.content,
+			lang: scriptLang(script.lang)
+		}];
+	}
+	let out = "";
+	let lang = "js";
+	let bindings;
+	if (descriptor.script !== null) {
+		const script = compileScript(descriptor, {
+			id,
+			sourceMap: false,
+			fs: VUE_FS
+		});
+		out = script.content;
+		lang = scriptLang(script.lang);
+		bindings = script.bindings;
+	}
+	const template = descriptor.template;
+	if (template !== null && template.src === void 0) {
+		const compiled = compileTemplate({
+			source: template.content,
+			filename: file,
+			id,
+			...template.lang === void 0 ? {} : { preprocessLang: template.lang },
+			compilerOptions: bindings === void 0 ? {} : { bindingMetadata: bindings }
+		});
+		if (compiled.errors.length > 0) throw compileError(file, compiled.errors[0]);
+		out += (out === "" ? "" : "\n") + compiled.code;
+	}
+	return [{
+		code: out,
+		lang
+	}];
+}
+/**
+* Style blocks in another language (`lang="scss"`) need preprocessors the
+* scan does not run, and Svelte's compiler would reject them. Their content
+* cannot hold calls, so it is blanked; line breaks stay for readable errors.
+*/
+function blankForeignStyles(code) {
+	return code.replace(/(<style\b[^>]*\b(?:lang|type)\s*=\s*(?!["']?(?:text\/)?css["'\s>])[^>]*>)([\s\S]*?)(<\/style\s*>)/gi, (_all, open, body, close) => open + body.replace(/[^\n]/g, " ") + close);
+}
+function compileSvelte(compiler, file, code) {
+	const compile = pick(compiler, "compile");
+	if (compile === void 0) throw compileError(file, "the installed svelte/compiler does not export compile");
+	const version = pick(compiler, "VERSION") ?? "5";
+	const generate = Number.parseInt(version, 10) < 5 ? "dom" : "client";
+	try {
+		return [{
+			code: compile(blankForeignStyles(code), {
+				filename: file,
+				generate
+			}).js.code,
+			lang: "js"
+		}];
+	} catch (error) {
+		throw compileError(file, error);
+	}
+}
+async function compileAstro(compiler, file, code) {
+	const transform = pick(compiler, "transform");
+	if (transform === void 0) throw compileError(file, "the installed Astro compiler does not export transform");
+	let result;
+	try {
+		result = await transform(code, {
+			filename: file,
+			normalizedFilename: file,
+			internalURL: "astro/runtime/server/index.js"
+		});
+	} catch (error) {
+		throw compileError(file, error);
+	}
+	const failure = result.diagnostics?.find((d) => d.severity === 1);
+	if (failure !== void 0) throw compileError(file, failure.text ?? failure.message ?? "syntax error");
+	const modules = [{
+		code: result.code,
+		lang: "ts"
+	}];
+	for (const script of result.scripts ?? []) if (script.type === "inline" && typeof script.code === "string") modules.push({
+		code: script.code,
+		lang: "ts"
+	});
+	return modules;
+}
+async function compileMdx(compiler, file, code) {
+	const compile = pick(compiler, "compile");
+	if (compile === void 0) throw compileError(file, "the installed @mdx-js/mdx does not export compile");
+	try {
+		const output = await compile({
+			value: code,
+			path: file
+		}, { development: false });
+		return [{
+			code: String(output),
+			lang: "js"
+		}];
+	} catch (error) {
+		throw compileError(file, error);
+	}
+}
+/**
+* Every module `file` compiles to, component first. Throws a
+* `DiagnosticError`: `extract-missing-compiler` when the project has no
+* compiler for the file, `extract-parse-error` when compilation fails.
+*/
+async function compileModules(file, code) {
+	const kind = sfcKind(file);
+	if (kind === null) throw compileError(file, "not a .vue, .svelte, .astro or .mdx file");
+	const compiler = await loadCompiler(kind, file).catch((error) => {
+		throw compileError(file, error);
+	});
+	if (compiler === null) throw missingCompiler(kind, file);
+	switch (kind) {
+		case "vue": try {
+			return compileVue(compiler, file, code);
+		} catch (error) {
+			throw isDiagnosticError(error) ? error : compileError(file, error);
+		}
+		case "svelte": return compileSvelte(compiler, file, code);
+		case "astro": return compileAstro(compiler, file, code);
+		case "mdx": return compileMdx(compiler, file, code);
+	}
+}
+/**
+* Files extracted by parse-only extraction and files compiled, by fallback
+* reason, since the process started (`compiled` counts every reason). For
+* tests and benchmarks; nothing reads them to decide anything.
+*/
+const sfcStats = {
+	parsed: 0,
+	compiled: 0,
+	fallbacks: /* @__PURE__ */ new Map()
+};
+/** Counts a compiled `.vue`/`.svelte` file under the reason parse-only extraction gave up. */
+function countFallback(reason) {
+	sfcStats.compiled++;
+	sfcStats.fallbacks.set(reason, (sfcStats.fallbacks.get(reason) ?? 0) + 1);
+}
+/**
+* The module parse-only extraction scans for a `.vue` or `.svelte` file
+* (§2.5.6, §6 D232), or the reason it cannot prove the result equal to
+* compiling the file: `.astro` and `.mdx` files, a missing compiler or a
+* file the parser rejects included, which {@link compileModules} then
+* reports.
+*/
+async function parseOnlyModule(file, code) {
+	const kind = sfcKind(file);
+	if (kind !== "vue" && kind !== "svelte") return { fallback: kind ?? "not-sfc" };
+	let compiler;
+	try {
+		compiler = await loadCompiler(kind, file);
+	} catch {
+		return { fallback: "compiler" };
+	}
+	if (compiler === null) return { fallback: "compiler" };
+	return kind === "vue" ? vueParseOnly(compiler, file, code) : svelteParseOnly(compiler, file, blankForeignStyles(code));
+}
+//#endregion
+//#region src/core/extract/worker.ts
+/**
+* One file's scan, and the `worker_threads` entry of the scan pool
+* (INTERNALS §2.5.6). `scanProject` runs `scanSource` in-process for small
+* scans and in this module's workers when many files miss the cache; both
+* paths run the same function, so the pool cannot change a result.
+*
+* Kept free of the cache, the config loader and `VERSION` (a JSON import),
+* so a worker loads only what scanning needs.
+*/
+/** The scan's part of `config`, for a worker. */
+function scanConfig(config) {
+	const { root, sourceLocale, project, extraction, strict } = config;
+	return {
+		root,
+		sourceLocale,
+		project,
+		extraction,
+		strict
+	};
+}
+/** Diagnostics that make `ProjectScan.aborted` true. */
+const ABORT_CODES = /* @__PURE__ */ new Set([
+	"extract-parse-error",
+	"extract-missing-compiler",
+	"extract-empty-root"
+]);
+/**
+* Assigns original-file positions to occurrences found in compiled output
+* (§2.5.1): each literal is searched after the previous occurrence of the
+* same literal, so repeated strings get successive positions. When the
+* compiler emitted a literal more often than the file spells it, the extra
+* occurrence keeps the last position found.
+*/
+function locate(text, occurrences) {
+	const last = /* @__PURE__ */ new Map();
+	for (const occurrence of occurrences) {
+		const previous = last.get(occurrence.source);
+		const found = locateLiteral(text, occurrence.source, previous === void 0 ? 0 : previous.offset + 1);
+		const at = found ?? previous;
+		if (at === void 0) continue;
+		occurrence.line = at.line;
+		occurrence.column = at.column;
+		if (found !== null) last.set(occurrence.source, found);
+	}
+}
+/**
+* The modules of a `.vue`/`.svelte`/`.astro`/`.mdx` file: the parse-only
+* module when it can stand for compilation (§6 D232), otherwise what the
+* project's compiler produces. A parse-only module the parser rejects is
+* compiled too, so a syntax error is reported as compiling reports it.
+*/
+async function sfcModules(task, compile) {
+	if (!compile) {
+		const quick = await parseOnlyModule(task.file, task.text);
+		if ("code" in quick) try {
+			const parsed = parseModule(quick.code, quick.lang, task.refFile);
+			sfcStats.parsed++;
+			return [{
+				code: quick.code,
+				lang: quick.lang,
+				parsed
+			}];
+		} catch (error) {
+			if (!isDiagnosticError(error)) throw error;
+			countFallback("syntax");
+		}
+		else countFallback(quick.fallback);
+	}
+	return compileModules(task.file, task.text);
+}
+function mentionsVi18n(text, needles) {
+	for (const needle of needles) if (text.includes(needle)) return true;
+	return false;
+}
+/**
+* Scans one file: framework files are read parse-only or compiled first
+* (each resulting module scanned on its own, positions recovered by
+* search), scripts are parsed as they are. A file whose text names no
+* import source, wrapper or global cannot bind a vi18n call and is not
+* parsed at all.
+*/
+async function scanSource(task, config, codec, options = {}) {
+	const result = {
+		occurrences: [],
+		diagnostics: [],
+		aborted: false
+	};
+	if (!mentionsVi18n(task.text, sourceNeedles(config))) return result;
+	const sfc = sfcKind(task.file) !== null;
+	try {
+		const modules = sfc ? await sfcModules(task, options.compile === true) : [{
+			code: task.text,
+			lang: langFromId(task.file)
+		}];
+		for (const module of modules) {
+			let parsed = module.parsed ?? parseModule(module.code, module.lang, task.refFile);
+			let specifiers = sourceSpecifiers(listImports(parsed), task.file, config);
+			const names = module.lang.endsWith("x") ? macroNames(listImports(parsed), specifiers) : null;
+			if (names !== null && names.size > 0) {
+				const sink = new MagicString(module.code);
+				const expanded = expandMacros(parsed, sink, {
+					names,
+					refFile: task.refFile,
+					keepLines: true
+				});
+				for (const diagnostic of expanded.diagnostics) result.diagnostics.push(diagnostic);
+				if (expanded.edited) {
+					parsed = parseModule(sink.toString(), module.lang, task.refFile);
+					specifiers = sourceSpecifiers(listImports(parsed), task.file, config);
+				}
+			}
+			const scan = scanModule(parsed, {
+				codec,
+				refFile: task.refFile,
+				sourceSpecifiers: specifiers,
+				aliases: config.extraction.aliases,
+				globals: config.extraction.globals,
+				moduleScope: config.strict.moduleScope,
+				warnings: true,
+				exactPositions: !sfc,
+				sourceLocale: config.sourceLocale,
+				...config.extraction.dependencies.length === 0 ? {} : { libraryIds: libraryIds(config) }
+			});
+			for (const occurrence of scan.occurrences) result.occurrences.push(occurrence);
+			for (const diagnostic of scan.diagnostics) result.diagnostics.push(diagnostic);
+		}
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		const diagnostic = {
+			...error.diagnostic,
+			file: task.refFile
+		};
+		if (sfc) {
+			delete diagnostic.line;
+			delete diagnostic.column;
+			diagnostic.message = diagnostic.message.replaceAll(task.file, task.refFile);
+		}
+		result.occurrences.length = 0;
+		result.diagnostics.push(diagnostic);
+	}
+	if (sfc) locate(task.text, result.occurrences);
+	for (const diagnostic of result.diagnostics) if (ABORT_CODES.has(diagnostic.code)) result.aborted = true;
+	return result;
+}
+/** Marks this module's own workers, so importing it in any other thread starts nothing. */
+const WORKER_MARKER = "vi18n:scan-worker";
+const init = workerData;
+if (!isMainThread && parentPort !== null && init?.marker === "vi18n:scan-worker") {
+	const port = parentPort;
+	const config = init.config;
+	const codec = createCodec(init.idLength);
+	armRawParsing();
+	port.on("message", (request) => {
+		(async () => {
+			try {
+				const results = [];
+				for (const task of request.tasks) results.push(await scanSource(task, config, codec));
+				port.postMessage({
+					batch: request.batch,
+					results
+				});
+			} catch (error) {
+				const { message, stack } = error instanceof Error ? error : new Error(String(error));
+				port.postMessage({
+					batch: request.batch,
+					error: stack === void 0 ? { message } : {
+						message,
+						stack
+					}
+				});
+			}
+		})();
+	});
+}
+//#endregion
+export { expandMacros as a, armRawParsing as c, scanSource as i, langFromId as l, WORKER_MARKER as n, macroNames as o, scanConfig as r, decodeEntities as s, ABORT_CODES as t, parseModule as u };