@x18n/builtins 0.0.0 → 0.0.2

package/dist/vue-6FYzIrQl.mjs

@@ -1,730 +0,0 @@
-//#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;
-const keyPathComponents = /* @__PURE__ */ new Map([
-	["i18n-t", "keypath"],
-	["I18nT", "keypath"],
-	["i18n", "path"],
-	["i18n-d", "path"]
-]);
-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 {}
-	}
-	/** `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 (keyPathComponents.get(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 && keyPathComponents.get(element.tag) === prop.arg.content && /^\s*(['"`]).*\1\s*$/.test(exp.content)) {
-				const start = exp.loc.start.offset + exp.content.search(/['"`]/) + 1;
-				const raw = exp.content.trim().slice(1, -1);
-				this.out.usages.push({
-					raw,
-					range: {
-						start,
-						end: start + raw.length
-					},
-					kind: "call",
-					dynamic: false
-				});
-				return;
-			}
-			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 };