@x18n/builtins 0.0.2 → 0.0.5

package/dist/vue-5GFR5hft.mjs

@@ -0,0 +1,727 @@
+//#region src/scanners/js.ts
+const hardStringIgnoredAttributes = /* @__PURE__ */ new Set([
+	"class",
+	"className",
+	"style",
+	"key",
+	"ref",
+	"id",
+	"href",
+	"src",
+	"type",
+	"name",
+	"for",
+	"htmlFor",
+	"role",
+	"slot",
+	"as",
+	"to",
+	"target",
+	"rel",
+	"lang",
+	"xmlns",
+	"viewBox",
+	"d",
+	"fill",
+	"stroke"
+]);
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "start" in value;
+}
+function isStringLiteral(node) {
+	return node?.type === "Literal" && typeof node.value === "string";
+}
+/** Inner range of a quoted literal. */
+function innerRange(node) {
+	return {
+		start: node.start + 1,
+		end: node.end - 1
+	};
+}
+function unwrap(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression" || current.type === "AwaitExpression" || current.type === "ChainExpression") current = current.type === "AwaitExpression" ? current.argument : current.expression;
+	return current;
+}
+/** `a.b.c` for identifier and member chains, `this.` dropped; undefined for anything else. */
+function calleeName(node) {
+	const target = unwrap(node);
+	if (target.type === "Identifier") return target.name;
+	if (target.type === "ThisExpression") return "this";
+	if (target.type === "MemberExpression" && !target.computed && target.property.type === "Identifier") {
+		const object = calleeName(target.object);
+		if (object === void 0) return void 0;
+		return object === "this" ? target.property.name : `${object}.${target.property.name}`;
+	}
+}
+function jsxName(node) {
+	if (node.type === "JSXIdentifier") return node.name;
+	if (node.type === "JSXMemberExpression") {
+		const object = node.object.type === "JSXIdentifier" ? node.object.name : node.object.type === "JSXMemberExpression" ? jsxName(node.object) : void 0;
+		return object ? `${object}.${node.property.name}` : void 0;
+	}
+}
+function propertyName(node) {
+	if (node.type === "Identifier") return node.name;
+	if (isStringLiteral(node)) return node.value;
+}
+function objectProperty(object, name) {
+	for (const property of object.properties) if (property.type === "Property" && !property.computed && propertyName(property.key) === name) return property.value;
+}
+var FileScan = class {
+	text;
+	offset;
+	collectHardStrings;
+	ignoredCallees;
+	usages = [];
+	keySlots = [];
+	hardStrings = [];
+	frames = [/* @__PURE__ */ new Map()];
+	constants = /* @__PURE__ */ new Map();
+	/** Several specs may share a callee, for example lingui `t('id')` and `t({ id })`. */
+	declared = /* @__PURE__ */ new Map();
+	factories = /* @__PURE__ */ new Map();
+	typed = /* @__PURE__ */ new Map();
+	consumed = /* @__PURE__ */ new Set();
+	constructor(text, offset, calls, collectHardStrings, ignoredCallees = /* @__PURE__ */ new Set()) {
+		this.text = text;
+		this.offset = offset;
+		this.collectHardStrings = collectHardStrings;
+		this.ignoredCallees = ignoredCallees;
+		for (const spec of calls) for (const name of [spec.callee].flat()) if (spec.factory) {
+			const list = this.factories.get(name) ?? [];
+			this.factories.set(name, list);
+			list.push(spec);
+		} else if (spec.types?.length) {
+			for (const type of spec.types) this.typed.set(type, spec);
+			this.declare(name, spec);
+		} else this.declare(name, spec);
+	}
+	range(range) {
+		return {
+			start: range.start + this.offset,
+			end: range.end + this.offset
+		};
+	}
+	declare(name, spec) {
+		const list = this.declared.get(name) ?? [];
+		this.declared.set(name, list);
+		list.push(spec);
+	}
+	lookup(name) {
+		return this.lookupAll(name)[0];
+	}
+	lookupAll(name) {
+		for (let i = this.frames.length - 1; i >= 0; i--) {
+			const binding = this.frames[i].get(name);
+			if (binding) return [binding];
+		}
+		const specs = this.declared.get(name);
+		if (specs) return specs.map((spec) => ({ spec }));
+		const dot = name.indexOf(".");
+		if (dot > 0) {
+			const root = this.lookup(name.slice(0, dot));
+			if (root?.spec.returns?.some((ret) => ret.endsWith(name.slice(dot)))) return [root];
+		}
+		return [];
+	}
+	bind(name, binding) {
+		this.frames.at(-1).set(name, binding);
+	}
+	/** ---- Reading arguments ---- */
+	stringArg(value) {
+		if (!value) return void 0;
+		if ("props" in value) return void 0;
+		const node = unwrap(value);
+		if (isStringLiteral(node)) return node.value;
+		if (node.type === "ArrayExpression" && node.elements[0] && isStringLiteral(node.elements[0])) return node.elements[0].value;
+		if (node.type === "JSXExpressionContainer" && node.expression.type !== "JSXEmptyExpression") return this.stringArg(node.expression);
+		if (node.type === "Identifier") {
+			const constant = this.constants.get(node.name);
+			return constant && isStringLiteral(constant) ? constant.value : void 0;
+		}
+	}
+	argValues(args, source, fallback) {
+		const arg = args[typeof source === "number" ? source : source?.arg ?? fallback];
+		const property = typeof source === "object" ? source.property : void 0;
+		if (!arg || property === void 0) return arg ? [arg] : [];
+		return property.split(".").reduce((values, segment) => values.flatMap((value) => {
+			if ("props" in value) {
+				const prop = value.props.get(segment);
+				return prop ? [prop] : [];
+			}
+			const node = unwrap(value);
+			if (node.type === "JSXExpressionContainer" && node.expression.type === "ObjectExpression") return segment === "*" ? this.allValues(node.expression) : [objectProperty(node.expression, segment)].filter(isNode);
+			if (node.type !== "ObjectExpression") return [];
+			return segment === "*" ? this.allValues(node) : [objectProperty(node, segment)].filter(isNode);
+		}), [arg]);
+	}
+	allValues(object) {
+		return object.properties.flatMap((p) => p.type === "Property" ? [p.value] : []);
+	}
+	/** ---- Usages ---- */
+	addKey(value, binding, namespace) {
+		if ("props" in value) return;
+		const node = unwrap(value);
+		const base = {
+			namespace: namespace ?? binding.namespace,
+			keyPrefix: binding.keyPrefix
+		};
+		if (isStringLiteral(node)) {
+			this.consumed.add(node.start);
+			this.keySlots.push(this.range(innerRange(node)));
+			this.usages.push({
+				...base,
+				raw: node.value,
+				range: this.range(innerRange(node)),
+				kind: "call",
+				dynamic: false
+			});
+			return;
+		}
+		if (node.type === "JSXExpressionContainer") {
+			if (node.expression.type !== "JSXEmptyExpression") this.addKey(node.expression, binding, namespace);
+			return;
+		}
+		if (node.type === "TemplateLiteral") {
+			const first = node.quasis[0];
+			const raw = first.value.cooked ?? first.value.raw;
+			this.consumed.add(node.start);
+			const range = this.range({
+				start: node.start + 1,
+				end: node.start + 1 + raw.length
+			});
+			this.usages.push({
+				...base,
+				raw,
+				range,
+				kind: "call",
+				dynamic: node.expressions.length === 0 ? false : raw ? "prefix" : "unknown"
+			});
+			return;
+		}
+		if (node.type === "ConditionalExpression") {
+			this.addKey(node.consequent, binding, namespace);
+			this.addKey(node.alternate, binding, namespace);
+			return;
+		}
+		if (node.type === "ArrowFunctionExpression" && node.params[0]?.type === "Identifier") return this.addSelector(node.params[0].name, node.body, base);
+		const constant = node.type === "Identifier" ? this.constants.get(node.name) : node.type === "MemberExpression" ? this.memberConstant(node) : void 0;
+		if (constant && isStringLiteral(constant)) {
+			this.usages.push({
+				...base,
+				raw: constant.value,
+				range: this.range(innerRange(constant)),
+				kind: "constant",
+				dynamic: false
+			});
+			return;
+		}
+		this.usages.push({
+			...base,
+			raw: this.text.slice(node.start, node.end),
+			range: this.range({
+				start: node.start,
+				end: node.end
+			}),
+			kind: "call",
+			dynamic: "unknown"
+		});
+	}
+	/** i18next `t($ => $.a.b)`. */
+	addSelector(param, body, base) {
+		const segments = [];
+		let node = unwrap(body);
+		let end = node.end;
+		while (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
+			segments.unshift(node.property.name);
+			node = unwrap(node.object);
+		}
+		if (node.type !== "Identifier" || node.name !== param || segments.length === 0) return;
+		const start = node.end + 1;
+		end = Math.max(end, start);
+		this.usages.push({
+			...base,
+			raw: segments.join("."),
+			range: this.range({
+				start,
+				end
+			}),
+			kind: "selector",
+			dynamic: false
+		});
+	}
+	memberConstant(node) {
+		if (node.computed || node.property.type !== "Identifier" || node.object.type !== "Identifier") return void 0;
+		const object = this.constants.get(node.object.name);
+		return object && object.type === "ObjectExpression" ? objectProperty(object, node.property.name) : void 0;
+	}
+	handleCall(name, args) {
+		const bindings = this.lookupAll(name).filter((binding) => !binding.spec.factory);
+		for (const binding of bindings) {
+			const namespace = binding.spec.namespace ? this.stringArg(this.argValues(args, binding.spec.namespace, 1)[0]) : void 0;
+			for (const value of this.argValues(args, binding.spec.key, 0)) {
+				if (bindings.length > 1 && !("props" in value) && unwrap(value).type === "ObjectExpression") continue;
+				this.addKey(value, binding, namespace);
+			}
+		}
+		return bindings.length > 0;
+	}
+	call(node) {
+		const name = calleeName(node.callee);
+		if (name !== void 0) this.handleCall(name, node.arguments);
+	}
+	jsx(node) {
+		const name = jsxName(node.name);
+		if (!name || !this.lookup(name)) return;
+		const props = /* @__PURE__ */ new Map();
+		for (const attribute of node.attributes) if (attribute.type === "JSXAttribute" && attribute.value && attribute.name.type === "JSXIdentifier") {
+			props.set(attribute.name.name, attribute.value);
+			if (isStringLiteral(attribute.value)) this.consumed.add(attribute.value.start);
+		}
+		this.handleCall(name, [{ props }]);
+	}
+	/** ---- Bindings ---- */
+	declarator(id, init) {
+		if (!init) return;
+		const value = unwrap(init);
+		if (id.type === "Identifier" && (isStringLiteral(value) || value.type === "ObjectExpression")) this.constants.set(id.name, value);
+		if (value.type === "CallExpression") {
+			const factory = calleeName(value.callee);
+			const specs = factory ? this.factories.get(factory) : void 0;
+			if (specs) this.bindFactory(id, value, specs);
+			return;
+		}
+		if (id.type === "Identifier" && (value.type === "Identifier" || value.type === "MemberExpression")) {
+			const name = calleeName(value);
+			const binding = name ? this.lookup(name) : void 0;
+			if (binding) this.bind(id.name, binding);
+		}
+	}
+	/** The first factory spec whose namespace and prefix sources all resolve, else the first spec. */
+	pickFactory(call, specs) {
+		const resolved = specs.map((spec) => {
+			const namespace = spec.namespace ? this.stringArg(this.argValues(call.arguments, spec.namespace, 0)[0]) : void 0;
+			const keyPrefix = spec.keyPrefix ? this.stringArg(this.argValues(call.arguments, spec.keyPrefix, 0)[0]) : void 0;
+			const complete = (!spec.namespace || namespace !== void 0) && (!spec.keyPrefix || keyPrefix !== void 0);
+			return {
+				binding: {
+					spec: {
+						callee: spec.callee,
+						returns: spec.returns
+					},
+					namespace,
+					keyPrefix
+				},
+				complete
+			};
+		});
+		return (resolved.find((r) => r.complete) ?? resolved[0]).binding;
+	}
+	bindFactory(id, call, specs) {
+		const binding = this.pickFactory(call, specs);
+		const returns = (binding.spec.returns ?? ["t"]).filter((name) => !name.includes("."));
+		if (id.type === "Identifier") {
+			this.bind(id.name, binding);
+			return;
+		}
+		if (id.type !== "ObjectPattern") return;
+		for (const property of id.properties) {
+			if (property.type !== "Property") continue;
+			const key = propertyName(property.key);
+			const local = unwrap(property.value);
+			if (key && returns.includes(key) && local.type === "Identifier") this.bind(local.name, binding);
+			if (key && local.type === "Identifier" && this.declared.has(`${key}.t`)) this.bind(`${local.name}.t`, binding);
+		}
+	}
+	params(params) {
+		for (const param of params) {
+			const target = param.type === "TSParameterProperty" ? param.parameter : param;
+			if (target.type !== "Identifier" || !target.typeAnnotation) continue;
+			const annotation = target.typeAnnotation.typeAnnotation;
+			const typeName = annotation.type === "TSTypeReference" && annotation.typeName.type === "Identifier" ? annotation.typeName.name : void 0;
+			const spec = typeName ? this.typed.get(typeName) : void 0;
+			if (spec) this.bind(target.name, { spec: {
+				...spec,
+				types: void 0
+			} });
+		}
+	}
+	importSpecifier(node) {
+		const imported = node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+		const spec = this.declared.get(imported)?.[0];
+		if (spec && imported !== node.local.name) this.bind(node.local.name, { spec });
+	}
+	/** ---- Hard strings ---- */
+	hard(text, range, kind, attribute) {
+		if (!this.collectHardStrings || !/\p{L}/u.test(text)) return;
+		this.hardStrings.push({
+			text,
+			range: this.range(range),
+			kind,
+			...attribute ? { attribute } : {}
+		});
+	}
+	ignoredCall(name) {
+		return name !== void 0 && (name.startsWith("console.") || name === "require" || this.ignoredCallees.has(name));
+	}
+	/** ---- Walk ---- */
+	walk(node, parent, parentKey) {
+		const scoped = node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "BlockStatement";
+		if (scoped) this.frames.push(/* @__PURE__ */ new Map());
+		this.visit(node, parent, parentKey);
+		for (const [key, child] of Object.entries(node)) {
+			if (key === "parent") continue;
+			if (Array.isArray(child)) {
+				for (const item of child) if (isNode(item)) this.walk(item, node, key);
+			} else if (isNode(child)) this.walk(child, node, key);
+		}
+		if (scoped) this.frames.pop();
+	}
+	visit(node, parent, parentKey) {
+		switch (node.type) {
+			case "CallExpression":
+				this.call(node);
+				break;
+			case "JSXOpeningElement":
+				this.jsx(node);
+				break;
+			case "VariableDeclarator":
+				this.declarator(node.id, node.init);
+				break;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				this.params(node.params);
+				break;
+			case "ImportSpecifier":
+				this.importSpecifier(node);
+				break;
+			case "JSXText": {
+				const text = node.value.trim();
+				if (text) this.hard(text, {
+					start: node.start + node.value.indexOf(text),
+					end: node.start + node.value.indexOf(text) + text.length
+				}, "jsx-text");
+				break;
+			}
+			case "Literal":
+			case "TemplateLiteral": this.literal(node, parent, parentKey);
+		}
+	}
+	literal(node, parent, parentKey) {
+		if (this.consumed.has(node.start) || !parent) return;
+		if (parent.type === "JSXAttribute") {
+			const name = parent.name.type === "JSXIdentifier" ? parent.name.name : "";
+			if (isStringLiteral(node) && !hardStringIgnoredAttributes.has(name) && !name.startsWith("data-") && !name.startsWith("aria-")) this.hard(node.value, {
+				start: parent.start,
+				end: parent.end
+			}, "jsx-attribute", name);
+			return;
+		}
+		if (parent.type === "ImportDeclaration" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportAllDeclaration" || parent.type === "TSLiteralType" || parent.type === "ImportExpression" || parent.type === "TSExternalModuleReference" || parent.type === "TSModuleDeclaration" || parent.type === "Property" && parentKey === "key" || parent.type === "MemberExpression" && parentKey === "property" || parent.type === "ExpressionStatement" || parent.type === "BinaryExpression" || parent.type === "SwitchCase" || parent.type === "CallExpression" && this.ignoredCall(calleeName(parent.callee))) return;
+		if (isStringLiteral(node)) this.hard(node.value, {
+			start: node.start,
+			end: node.end
+		}, "js-string");
+		else if (node.type === "TemplateLiteral") this.template(node);
+	}
+	/** `Hello ${user.name}` becomes `Hello {0}` with the argument `name: user.name`. */
+	template(node) {
+		if (!this.collectHardStrings) return;
+		const args = node.expressions.map((expression, i) => {
+			const source = this.text.slice(expression.start, expression.end);
+			return {
+				name: expression.type === "Identifier" ? expression.name : expression.type === "MemberExpression" && expression.property.type === "Identifier" ? expression.property.name : `arg${i}`,
+				expression: source
+			};
+		});
+		const text = node.quasis.map((q, i) => `${q.value.cooked ?? q.value.raw}${i < args.length ? `{${i}}` : ""}`).join("");
+		if (/\p{L}/u.test(text)) this.hardStrings.push({
+			text,
+			range: this.range({
+				start: node.start,
+				end: node.end
+			}),
+			kind: "js-template",
+			args
+		});
+	}
+	markers(program, comments) {
+		for (const comment of comments) {
+			const marker = /@x18n-keys?\b/.exec(comment.value)?.[0];
+			if (!marker) continue;
+			const next = this.firstAfter(program, comment.end);
+			if (!next) continue;
+			const literals = marker === "@x18n-keys" ? this.literalsIn(next) : isStringLiteral(next) ? [next] : [];
+			for (const literal of literals) if (isStringLiteral(literal)) this.usages.push({
+				raw: literal.value,
+				range: this.range(innerRange(literal)),
+				kind: "marker",
+				dynamic: false
+			});
+		}
+	}
+	firstAfter(root, offset) {
+		let best;
+		const visit = (node) => {
+			if (node.end <= offset || best && node.start > best.start) return;
+			if (node.start >= offset && (node.type === "Literal" || node.type === "ArrayExpression" || node.type === "ObjectExpression")) {
+				if (!best || node.start < best.start) best = node;
+				return;
+			}
+			for (const [key, child] of Object.entries(node)) {
+				if (key === "parent") continue;
+				for (const item of [child].flat()) if (isNode(item)) visit(item);
+			}
+		};
+		visit(root);
+		return best;
+	}
+	literalsIn(node) {
+		if (isStringLiteral(node)) return [node];
+		if (node.type === "ArrayExpression") return node.elements.flatMap((element) => element ? this.literalsIn(element) : []);
+		if (node.type === "ObjectExpression") return this.allValues(node).flatMap((value) => this.literalsIn(value));
+		return [];
+	}
+	result() {
+		return {
+			usages: this.usages,
+			keySlots: this.keySlots,
+			hardStrings: this.hardStrings
+		};
+	}
+};
+let parser;
+/** Loads oxc lazily: native in Node, WASM through the package's browser export. */
+function loadParser() {
+	parser ??= import("oxc-parser").then((mod) => mod.parseSync);
+	return parser;
+}
+function scanSource(parse, text, options) {
+	const source = options.expression ? `(${text})` : text;
+	const shift = options.expression ? -1 : 0;
+	const result = parse(options.filename, source, {
+		sourceType: "module",
+		range: false
+	});
+	const scan = new FileScan(source, (options.offset ?? 0) + shift, options.calls, options.hardStrings !== false, new Set(options.ignoreCallees));
+	scan.walk(result.program, void 0, "");
+	scan.markers(result.program, result.comments);
+	return scan.result();
+}
+/** The AST scanner for JS and TS, driven by call specs (`usage.calls`). */
+function js() {
+	return {
+		name: "x18n:scanner-js",
+		scanners: [{
+			id: "js",
+			extensions: [
+				"js",
+				"jsx",
+				"mjs",
+				"cjs",
+				"ts",
+				"tsx",
+				"mts",
+				"cts"
+			],
+			async scan(file, ctx) {
+				return scanSource(await loadParser(), file.text, {
+					calls: ctx.calls,
+					filename: file.path,
+					hardStrings: true,
+					ignoreCallees: ctx.config.extract.ignoreCallees
+				});
+			}
+		}]
+	};
+}
+//#endregion
+//#region src/scanners/vue.ts
+let compiler;
+function loadVueCompiler() {
+	compiler ??= import("@vue/compiler-sfc");
+	return compiler;
+}
+const ELEMENT = 1;
+const TEXT = 2;
+const SIMPLE_EXPRESSION = 4;
+const INTERPOLATION = 5;
+const ATTRIBUTE = 6;
+/** `keypath` is the vue-i18n prop for a key, on `<i18n-t>` and on the app's own wrappers of it; `path` on the legacy components. */
+function isKeyAttribute(tag, name) {
+	return name === "keypath" || name === "path" && (tag === "i18n" || tag === "i18n-d");
+}
+const ignoredAttributes = /* @__PURE__ */ new Set([
+	"class",
+	"style",
+	"key",
+	"ref",
+	"id",
+	"name",
+	"type",
+	"href",
+	"src",
+	"to",
+	"for",
+	"role",
+	"lang",
+	"target",
+	"rel",
+	"is",
+	"slot"
+]);
+function merge(into, result) {
+	into.usages.push(...result.usages);
+	into.keySlots.push(...result.keySlots ?? []);
+	into.hardStrings.push(...result.hardStrings ?? []);
+}
+var TemplateScan = class {
+	parse;
+	calls;
+	out = {
+		usages: [],
+		keySlots: [],
+		hardStrings: []
+	};
+	constructor(parse, calls) {
+		this.parse = parse;
+		this.calls = calls;
+	}
+	expression(content, offset) {
+		if (!content.trim()) return;
+		try {
+			merge(this.out, scanSource(this.parse, content, {
+				calls: this.calls,
+				offset,
+				filename: "template.ts",
+				expression: true,
+				hardStrings: false
+			}));
+		} catch {}
+	}
+	/** `:keypath="cond ? 'a' : 'b'"`: the expression is read as the key argument of a translate call. */
+	keyExpression(content, offset) {
+		const callee = "__x18nKey(";
+		try {
+			merge(this.out, scanSource(this.parse, `${callee}${content})`, {
+				calls: [{ callee: "__x18nKey" }],
+				offset: offset - 10,
+				filename: "template.ts",
+				hardStrings: false
+			}));
+		} catch {}
+	}
+	/** `v-t="'key'"` and `v-t="{ path: 'key' }"`. */
+	vt(dir) {
+		const exp = dir.exp;
+		if (!exp || !("content" in exp)) return;
+		const offset = exp.loc.start.offset;
+		const literal = /^\s*(['"`])(.*)\1\s*$/.exec(exp.content) ?? /path\s*:\s*(['"`])(.*?)\1/.exec(exp.content);
+		if (!literal) return;
+		const start = offset + exp.content.indexOf(literal[2], literal.index);
+		const range = {
+			start,
+			end: start + literal[2].length
+		};
+		this.out.usages.push({
+			raw: literal[2],
+			range,
+			kind: "call",
+			dynamic: false
+		});
+		this.out.keySlots.push(range);
+	}
+	attribute(element, prop) {
+		if (prop.type === ATTRIBUTE) {
+			const value = prop.value;
+			if (!value) return;
+			const range = {
+				start: value.loc.start.offset + 1,
+				end: value.loc.end.offset - 1
+			};
+			if (isKeyAttribute(element.tag, prop.name)) {
+				this.out.usages.push({
+					raw: value.content,
+					range,
+					kind: "call",
+					dynamic: false
+				});
+				this.out.keySlots.push(range);
+			} else if (!ignoredAttributes.has(prop.name) && !prop.name.startsWith("data-") && /\p{L}/u.test(value.content)) this.out.hardStrings.push({
+				text: value.content,
+				range: {
+					start: prop.loc.start.offset,
+					end: prop.loc.end.offset
+				},
+				kind: "vue-attribute",
+				attribute: prop.name
+			});
+			return;
+		}
+		if (prop.name === "t") {
+			this.vt(prop);
+			return;
+		}
+		const exp = prop.exp;
+		if (exp && "content" in exp) {
+			if (prop.name === "bind" && prop.arg && "content" in prop.arg && isKeyAttribute(element.tag, prop.arg.content)) this.keyExpression(exp.content, exp.loc.start.offset);
+			else this.expression(exp.content, exp.loc.start.offset);
+		}
+	}
+	node(node) {
+		if (node.type === INTERPOLATION && "content" in node.content) this.expression(node.content.content, node.content.loc.start.offset);
+		if (node.type === TEXT) {
+			const text = node.content.trim();
+			if (text && /\p{L}/u.test(text)) {
+				const start = node.loc.start.offset + node.content.indexOf(text);
+				this.out.hardStrings.push({
+					text,
+					range: {
+						start,
+						end: start + text.length
+					},
+					kind: "vue-template-text"
+				});
+			}
+		}
+		if (node.type === ELEMENT) for (const prop of node.props) this.attribute(node, prop);
+		if ("children" in node) {
+			for (const child of node.children) if (typeof child === "object" && child.type !== SIMPLE_EXPRESSION) this.node(child);
+		}
+	}
+};
+/** Vue SFCs: `<script>` through the `js` scanner, template expressions, `v-t`, `<i18n-t keypath>`. */
+function vue() {
+	return {
+		name: "x18n:scanner-vue",
+		scanners: [{
+			id: "vue",
+			extensions: ["vue"],
+			async scan(file, ctx) {
+				const [{ parse }, parseJs] = await Promise.all([loadVueCompiler(), loadParser()]);
+				const { descriptor } = parse(file.text, {
+					filename: file.path,
+					sourceMap: false,
+					ignoreEmpty: false
+				});
+				const template = new TemplateScan(parseJs, ctx.calls);
+				for (const script of [descriptor.script, descriptor.scriptSetup]) {
+					if (!script) continue;
+					const lang = script.lang ?? "js";
+					merge(template.out, scanSource(parseJs, script.content, {
+						calls: ctx.calls,
+						ignoreCallees: ctx.config.extract.ignoreCallees,
+						offset: script.loc.start.offset,
+						filename: `script.${lang === "tsx" || lang === "jsx" ? lang : lang === "ts" ? "ts" : "js"}`
+					}));
+				}
+				if (descriptor.template?.ast) template.node(descriptor.template.ast);
+				return template.out;
+			}
+		}]
+	};
+}
+//#endregion
+export { loadParser as a, js as i, vue as n, scanSource as o, calleeName as r, loadVueCompiler as t };