@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/validate-D6DJepZv.js

@@ -0,0 +1,365 @@
+import { d as diagnosticError, f as isDiagnosticError, i as normalizeSource, l as positionAt, o as isMF2Form, u as quoteStarts } from "./compile-Cc97JaW2.js";
+//#region src/core/icu/structure.ts
+/**
+* What a translation must keep from its source (INTERNALS §2.1.2).
+*
+* A name has one kind per message, with two exceptions that render the same
+* value with the same meaning: a plain `{x}` goes with any kind, and
+* `{x, number}` goes with a plural or selectordinal of `x` (the count the
+* plural selects on, as in `{count, plural, other {{count, number} items}}`).
+* Everything else changes what the value means and is a mismatch: `date` with
+* `time`, `plural` (cardinal) with `selectordinal`, `number` with `date`.
+*/
+/** Whether two uses of one name can share a value. */
+function compatibleKinds(a, b) {
+	return a === b || a === "argument" || b === "argument" || a === "number" && isPlural(b) || b === "number" && isPlural(a);
+}
+function isPlural(kind) {
+	return kind === "plural" || kind === "selectordinal";
+}
+/**
+* @throws {DiagnosticError} `icu-argument-mismatch` when a name is used with
+*   incompatible kinds, `icu-tag-mismatch` when a tag is both paired and standalone.
+*/
+function structureOf(message) {
+	const structure = {
+		args: /* @__PURE__ */ new Map(),
+		optionalArgs: /* @__PURE__ */ new Set(),
+		tags: /* @__PURE__ */ new Map()
+	};
+	const required = /* @__PURE__ */ new Set();
+	collect(message, false, structure, required);
+	for (const name of structure.args.keys()) if (!required.has(name)) structure.optionalArgs.add(name);
+	return structure;
+}
+function collect(nodes, inPlural, structure, required) {
+	for (const node of nodes) switch (node.type) {
+		case "literal":
+		case "pound": break;
+		case "argument":
+			use(node.name, "argument", inPlural, structure, required);
+			break;
+		case "number":
+		case "date":
+		case "time":
+			use(node.name, node.type, inPlural, structure, required);
+			break;
+		case "select":
+			use(node.name, "select", inPlural, structure, required);
+			for (const option of node.options) collect(option.value, inPlural, structure, required);
+			break;
+		case "plural":
+			use(node.name, node.pluralType === "cardinal" ? "plural" : "selectordinal", inPlural, structure, required);
+			for (const option of node.options) collect(option.value, true, structure, required);
+			break;
+		case "tag": {
+			const kind = node.children === null ? "standalone" : "paired";
+			const seen = structure.tags.get(node.name);
+			if (seen !== void 0 && seen !== kind) throw diagnosticError({
+				code: "icu-tag-mismatch",
+				severity: "error",
+				message: `<${node.name}> is used both as <${node.name}>…</${node.name}> and as <${node.name}/>: use one form`
+			});
+			structure.tags.set(node.name, kind);
+			if (node.children !== null) collect(node.children, inPlural, structure, required);
+			break;
+		}
+	}
+}
+function use(name, kind, inPlural, structure, required) {
+	if (!inPlural) required.add(name);
+	const seen = structure.args.get(name);
+	if (seen === void 0 || seen === "argument" || seen === "number" && isPlural(kind)) structure.args.set(name, kind);
+	else if (!compatibleKinds(seen, kind)) throw diagnosticError({
+		code: "icu-argument-mismatch",
+		severity: "error",
+		message: `{${name}} is used both as ${describe(seen)} and as ${describe(kind)}: rename one of them`
+	});
+}
+function describe(kind) {
+	return kind === "argument" ? "a plain argument" : `{…, ${kind}}`;
+}
+//#endregion
+//#region src/core/icu/validate.ts
+/**
+* Message validation (INTERNALS §2.1.3, PLAN §5.4), run at extract, compile,
+* AI post-check and CI. Parse errors are thrown by the parser; everything
+* here is found on a parsed AST and returned, so one call reports every
+* problem of a message at once.
+*/
+const CLDR_ORDER = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+const categoryCache = /* @__PURE__ */ new Map();
+function categoriesOf(locale) {
+	let entry = categoryCache.get(locale);
+	if (entry === void 0) {
+		const sorted = (type) => {
+			const found = new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories;
+			return CLDR_ORDER.filter((category) => found.includes(category));
+		};
+		entry = {
+			cardinal: sorted("cardinal"),
+			ordinal: sorted("ordinal")
+		};
+		categoryCache.set(locale, entry);
+	}
+	return entry;
+}
+function validateSource(message, options) {
+	const diagnostics = [];
+	checkMessage(message, options.locale, options.text, false, diagnostics);
+	return diagnostics;
+}
+function validateTranslation(translation, source, options) {
+	if (options.maxLength === void 0 && isLiteralOnly(translation) && isLiteralOnly(source) && hasQuietText(options.text)) return [];
+	const diagnostics = [];
+	const ai = options.ai === true;
+	const own = checkMessage(translation, options.locale, options.text, ai, diagnostics);
+	const expected = structureOrNull(source);
+	if (own !== null && expected !== null) compareStructure(own, expected, diagnostics);
+	if (options.maxLength !== void 0) {
+		const length = graphemeLength(longestRendering(translation));
+		if (length > options.maxLength) diagnostics.push({
+			code: "icu-max-length",
+			severity: ai ? "error" : "warning",
+			message: `Translation is ${length} characters long at its longest, over the limit of ${options.maxLength}: shorten it`
+		});
+	}
+	return diagnostics;
+}
+function isLiteralOnly(message) {
+	for (const node of message) if (node.type !== "literal") return false;
+	return true;
+}
+/** No apostrophe (the quote lint) and no character `scanLiteral` looks for. */
+function hasQuietText(text) {
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 39 || c >= 8234 && c <= 8297) return false;
+	}
+	return true;
+}
+/** Checks shared by sources and translations; returns the structure when it is valid. */
+function checkMessage(message, locale, text, ai, diagnostics) {
+	const state = {
+		locale,
+		ai,
+		diagnostics,
+		isolateDepth: 0,
+		isolateUnderflow: false,
+		bidiControl: -1
+	};
+	walk(message, state);
+	if (state.bidiControl !== -1) {
+		const char = String.fromCharCode(state.bidiControl);
+		diagnostics.push({
+			code: "icu-bidi-control",
+			severity: "error",
+			message: `Literal text contains the bidi control U+${hex(state.bidiControl)}, which can reorder the text around it: remove it (vi18n isolates values itself)`,
+			...positionOf(text, char)
+		});
+	}
+	if (state.isolateUnderflow || state.isolateDepth !== 0) diagnostics.push({
+		code: "icu-unbalanced-isolate",
+		severity: "error",
+		message: state.isolateUnderflow ? "U+2069 (pop directional isolate) closes an isolate that was never opened: remove it" : "A directional isolate (U+2066, U+2067 or U+2068) is never closed: add U+2069"
+	});
+	const structure = structureOrDiagnostic(message, diagnostics);
+	if (text.includes("'") && !isMF2Form(text)) {
+		const normalized = normalizeSource(text);
+		for (const offset of quoteStarts(normalized)) diagnostics.push({
+			code: "icu-apostrophe",
+			severity: "warning",
+			message: `This apostrophe starts quoted text, so what follows is printed literally: write ’ for an apostrophe, or '' if you need a straight one`,
+			...positionAt(normalized, offset)
+		});
+	}
+	return structure;
+}
+/** Bidi controls and isolates in literal text; options; plural categories. */
+function walk(nodes, state) {
+	for (const node of nodes) switch (node.type) {
+		case "literal":
+			scanLiteral(node.value, state);
+			break;
+		case "tag":
+			if (node.children !== null) walk(node.children, state);
+			break;
+		case "select":
+			requireOther(node.name, "select", node.options, state);
+			for (const option of node.options) walk(option.value, state);
+			break;
+		case "plural": {
+			const type = node.pluralType === "cardinal" ? "plural" : "selectordinal";
+			requireOther(node.name, type, node.options, state);
+			checkCategories(node.name, type, node.options, state);
+			for (const option of node.options) walk(option.value, state);
+			break;
+		}
+	}
+}
+function scanLiteral(value, state) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 8234 || c > 8297) continue;
+		if (c <= 8238) {
+			if (state.bidiControl === -1) state.bidiControl = c;
+		} else if (c >= 8294 && c <= 8296) state.isolateDepth++;
+		else if (c === 8297) {
+			if (state.isolateDepth === 0) state.isolateUnderflow = true;
+			else state.isolateDepth--;
+		}
+	}
+}
+/** The parser enforces this; hand-built and AI-produced ASTs may not have been parsed. */
+function requireOther(name, type, options, state) {
+	if (!options.some((option) => option.key === "other")) state.diagnostics.push({
+		code: "icu-missing-other",
+		severity: "error",
+		message: `{${name}, ${type}} needs an other {…} option`
+	});
+}
+function checkCategories(name, type, options, state) {
+	const { locale, ai, diagnostics } = state;
+	const categories = type === "plural" ? categoriesOf(locale).cardinal : categoriesOf(locale).ordinal;
+	const missing = categories.filter((category) => category !== "other" && !options.some((o) => o.key === category));
+	if (missing.length > 0) diagnostics.push({
+		code: "icu-plural-missing-category",
+		severity: ai ? "error" : "warning",
+		message: `{${name}, ${type}} has no ${missing.join(", ")} option, which ${locale} needs: add ${missing.length > 1 ? "them" : "it"}`
+	});
+	for (const option of options) {
+		const key = option.key;
+		if (key === "other" || key.startsWith("=")) continue;
+		if (!categories.includes(key)) diagnostics.push({
+			code: "icu-plural-unused-category",
+			severity: ai ? "error" : "warning",
+			message: `{${name}, ${type}} has a ${key} option, which ${locale} never selects: remove it`
+		});
+		else if (key === "one" && /(?<![\d.,])1(?![\d]|[.,]\d)/.test(directText(option.value))) diagnostics.push({
+			code: "icu-plural-one-literal",
+			severity: "warning",
+			message: `The one option of {${name}, ${type}} contains a literal 1, but one also matches other numbers in many languages: write # instead`
+		});
+	}
+}
+/** Literal text of an option, tags included, nested arguments excluded. */
+function directText(nodes) {
+	let text = "";
+	for (const node of nodes) if (node.type === "literal") text += node.value;
+	else if (node.type === "tag" && node.children !== null) text += directText(node.children);
+	else text += " ";
+	return text;
+}
+function structureOrDiagnostic(message, diagnostics) {
+	try {
+		return structureOf(message);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		diagnostics.push(error.diagnostic);
+		return null;
+	}
+}
+function structureOrNull(message) {
+	try {
+		return structureOf(message);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		return null;
+	}
+}
+/**
+* A translation may write any argument plainly (`{n}` for a plural count), a
+* plural's count as `{n, number}` (languages without plurals) and a source
+* `{n, number}` as a plural; any other kind change alters the meaning. It may
+* drop arguments the source uses only inside plural options.
+*/
+function compareStructure(own, source, diagnostics) {
+	const mismatch = (code, message) => diagnostics.push({
+		code,
+		severity: "error",
+		message
+	});
+	for (const [name, kind] of own.args) {
+		const expected = source.args.get(name);
+		if (expected === void 0) mismatch("icu-argument-mismatch", `The translation uses {${name}}, which the source does not have: remove it or use a source argument`);
+		else if (!translationKindFits(expected, kind)) mismatch("icu-argument-mismatch", `The translation uses {${name}} as ${describe(kind)}, but the source uses it as ${describe(expected)}: use the source's kind`);
+	}
+	for (const name of source.args.keys()) if (!own.args.has(name) && !source.optionalArgs.has(name)) mismatch("icu-argument-mismatch", `The translation lacks {${name}}: add it`);
+	for (const [name, kind] of source.tags) {
+		const ownKind = own.tags.get(name);
+		if (ownKind === void 0) mismatch("icu-tag-mismatch", `The translation lacks the tag ${tagForm(name, kind)}: add it`);
+		else if (ownKind !== kind) mismatch("icu-tag-mismatch", `The translation writes ${tagForm(name, ownKind)} where the source has ${tagForm(name, kind)}`);
+	}
+	for (const [name, kind] of own.tags) if (!source.tags.has(name)) mismatch("icu-tag-mismatch", `The translation adds the tag ${tagForm(name, kind)}, which the source does not have: remove it`);
+}
+function translationKindFits(source, translation) {
+	return translation === "argument" || source !== "argument" && compatibleKinds(source, translation);
+}
+function tagForm(name, kind) {
+	return kind === "paired" ? `<${name}>…</${name}>` : `<${name}/>`;
+}
+/**
+* The longest text a message can render, with each argument standing for its
+* name and `#` for one character; select and plural take their longest option.
+*/
+function longestRendering(nodes) {
+	let text = "";
+	for (const node of nodes) text += longestNode(node);
+	return text;
+}
+function longestNode(node) {
+	switch (node.type) {
+		case "literal": return node.value;
+		case "pound": return "#";
+		case "tag": return node.children === null ? "" : longestRendering(node.children);
+		case "select":
+		case "plural": {
+			let best = "";
+			let bestLength = -1;
+			for (const option of node.options) {
+				const text = longestRendering(option.value);
+				const length = graphemeLength(text);
+				if (length > bestLength) {
+					best = text;
+					bestLength = length;
+				}
+			}
+			return best;
+		}
+		default: return node.name;
+	}
+}
+let segmenter;
+/** User-perceived characters; strings below U+0300 without CR need no segmentation. */
+function graphemeLength(text) {
+	let simple = true;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c >= 768 || c === 13) {
+			simple = false;
+			break;
+		}
+	}
+	if (simple) return text.length;
+	segmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+	let count = 0;
+	for (const _ of segmenter.segment(text)) count++;
+	return count;
+}
+function positionOf(text, char) {
+	const normalized = normalizeSource(text);
+	const offset = normalized.indexOf(char);
+	return offset === -1 ? {} : positionAt(normalized, offset);
+}
+function hex(code) {
+	return code.toString(16).toUpperCase().padStart(4, "0");
+}
+//#endregion
+export { validateTranslation as n, validateSource as t };

package/dist/version-Byqi2guX.js

@@ -0,0 +1,28 @@
+import "node:path";
+import "node:crypto";
+import "node:fs";
+import "node:url";
+//#endregion
+//#region src/core/version.ts
+const VERSION = "0.1.1";
+let fingerprint;
+let cacheVersionMemo;
+/**
+* A fingerprint of the code this process runs. Packed, the hash the pack
+* inlined, which costs nothing. From source (the workspace's examples, the
+* bench and the tests), a hash of every `.ts` file under the `src/` this
+* module lives in, computed on first use and kept for the process: about
+* 10 ms for the 1.3 MB of source, paid only by processes that key a cache.
+*/
+function codeFingerprint() {
+	if (fingerprint !== void 0) return fingerprint;
+	fingerprint = "0UPRQnKMBktq7h16";
+	return fingerprint;
+}
+/** `VERSION` and `codeFingerprint()`: the version every cache key and `configHash` carries. */
+function cacheVersion() {
+	cacheVersionMemo ??= `${VERSION}+${codeFingerprint()}`;
+	return cacheVersionMemo;
+}
+//#endregion
+export { cacheVersion as n, VERSION as t };

package/dist/vite-scan-CT_vsp4g.js

@@ -0,0 +1,242 @@
+import { a as toPosix, i as listProjectFiles, o as aggregateOccurrences, t as refMapper } from "./project-Bw9UPIdx.js";
+import { t as ABORT_CODES } from "./worker-84U6uYB3.js";
+import { n as setCollector } from "./collect-Cx4_SKOe.js";
+import { createRequire } from "node:module";
+import { join, relative } from "node:path";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+//#region src/cli/vite-scan.ts
+/**
+* `vi18n extract --vite` (PLAN §4.5 P2, INTERNALS §2.5.9, §6 D234–D235):
+* the include scan through the project's own Vite pipeline, for projects
+* whose plugins change code before vi18n sees it (auto-imports, macros,
+* generated components). A Vite dev server is created in middleware mode
+* from the project's Vite config, every included file is transformed by
+* its plugins, and what `vi18n:extract` records for each module is
+* collected (`core/extract/collect.ts`). Nothing is bundled, served or
+* written by the server; the command then syncs the catalogs as usual.
+*/
+/** Files transformed at once: plugins await compilers and the file system. */
+const CONCURRENCY = 8;
+/** The project's `vite`, else the one vi18n itself resolves (its peer dependency). */
+async function loadVite(root) {
+	for (const from of [join(root, "package.json"), import.meta.url]) {
+		let path;
+		try {
+			path = createRequire(from).resolve("vite");
+		} catch {
+			continue;
+		}
+		return await import(pathToFileURL(path).href);
+	}
+	throw new Error("vite is not installed in the project");
+}
+/** How Vite requests a file: root-relative inside the root, `/@fs/` outside it. */
+function urlOf(root, file) {
+	const rel = toPosix(relative(root, file));
+	return rel.startsWith("../") || rel === ".." || /^[a-zA-Z]:/.test(rel) ? "/@fs" + (toPosix(file).startsWith("/") ? "" : "/") + toPosix(file) : "/" + rel;
+}
+function messageOf(error) {
+	return (error instanceof Error ? error.message : String(error)).split("\n")[0];
+}
+function collectorInto(collected, active) {
+	return {
+		module(id, messages) {
+			if (!active()) return;
+			let path = id.charCodeAt(0) === 0 ? id.slice(1) : id;
+			const query = path.indexOf("?");
+			if (query !== -1) path = path.slice(0, query);
+			path = toPosix(path);
+			let byId = collected.modules.get(path);
+			if (byId === void 0) collected.modules.set(path, byId = /* @__PURE__ */ new Map());
+			byId.set(id, messages);
+		},
+		diagnostic(diagnostic, path) {
+			if (!active()) return;
+			if (path !== void 0) collected.failed.add(toPosix(path));
+			collected.diagnostics.push(diagnostic);
+		}
+	};
+}
+/**
+* Transforms `file` in the first environment whose pipeline accepts it
+* (client, then the others: server-only code may import what a client
+* build refuses), then the modules the same file split into (`?vue&type=`,
+* Astro's `?astro&type=script`). Resolves with the failure to report, or
+* null.
+*/
+async function transformFile(server, root, file, collected) {
+	const path = toPosix(file);
+	const url = urlOf(root, file);
+	const names = Object.keys(server.environments).sort((a, b) => a === "client" ? -1 : b === "client" ? 1 : 0);
+	let firstError = null;
+	for (const name of names) {
+		const environment = server.environments[name];
+		try {
+			await environment.transformRequest(url);
+		} catch (error) {
+			if (collected.failed.has(path)) return null;
+			if (collected.modules.has(path)) return null;
+			firstError ??= error;
+			continue;
+		}
+		const main = await environment.moduleGraph.getModuleByUrl(url);
+		for (const part of main?.importedModules ?? []) {
+			if (part.file === null || toPosix(part.file) !== path || part.id === main?.id) continue;
+			try {
+				await environment.transformRequest(part.url);
+			} catch {}
+		}
+		return null;
+	}
+	return firstError === null ? null : messageOf(firstError);
+}
+/**
+* The project scan of `vi18n extract --vite`: the same `ProjectScan` as
+* `scanProject`, from what `vi18n:extract` records while the project's Vite
+* plugins transform each included file.
+*/
+async function scanWithVite(config) {
+	const ref = refMapper(config);
+	const listed = await listProjectFiles(config);
+	const leading = listed.emptyRoots.map((root) => ({
+		code: "extract-empty-root",
+		severity: "error",
+		message: `The include entry ${ref(root)} matches no file; fix project.include or project.exclude in the config`,
+		file: ref(root)
+	}));
+	let vite;
+	try {
+		vite = await loadVite(config.root);
+	} catch (error) {
+		return failedScan(leading, `vi18n extract --vite needs vite: ${messageOf(error)}`);
+	}
+	const collected = {
+		modules: /* @__PURE__ */ new Map(),
+		diagnostics: [],
+		failed: /* @__PURE__ */ new Set()
+	};
+	let active = false;
+	setCollector(collectorInto(collected, () => active));
+	let server;
+	try {
+		server = await vite.createServer({
+			configFile: viteConfigFile(config.root),
+			logLevel: "error",
+			clearScreen: false,
+			appType: "custom",
+			server: {
+				middlewareMode: true,
+				hmr: false,
+				ws: false,
+				watch: null,
+				preTransformRequests: false
+			},
+			optimizeDeps: {
+				noDiscovery: true,
+				include: []
+			},
+			plugins: [{
+				name: "vi18n:extract-vite",
+				enforce: "pre",
+				config: {
+					order: "pre",
+					handler(user) {
+						return user.root === void 0 ? { root: config.root } : {};
+					}
+				}
+			}]
+		});
+	} catch (error) {
+		setCollector(null);
+		return failedScan(leading, `the Vite config could not be loaded: ${messageOf(error)}`);
+	}
+	const failures = /* @__PURE__ */ new Map();
+	try {
+		if (!server.config.plugins.some((plugin) => plugin.name === "vi18n:extract")) return failedScan(leading, "vi18n extract --vite found no vi18n() plugin in the Vite config; add it, or run vi18n extract without --vite");
+		active = true;
+		const viteRoot = server.config.root ?? config.root;
+		let next = 0;
+		const lanes = [];
+		for (let lane = 0; lane < Math.min(CONCURRENCY, listed.files.length); lane++) lanes.push((async () => {
+			while (next < listed.files.length) {
+				const file = listed.files[next++];
+				const failure = await transformFile(server, viteRoot, file, collected);
+				if (failure !== null) failures.set(file, failure);
+			}
+		})());
+		await Promise.all(lanes);
+	} finally {
+		active = false;
+		setCollector(null);
+		await server.close();
+	}
+	const files = [];
+	const byRef = /* @__PURE__ */ new Map();
+	for (const diagnostic of collected.diagnostics) {
+		const key = diagnostic.file ?? "";
+		let list = byRef.get(key);
+		if (list === void 0) byRef.set(key, list = []);
+		list.push(diagnostic);
+	}
+	const diagnostics = [...leading];
+	for (const file of listed.files) {
+		const refFile = ref(file);
+		const fileDiagnostics = byRef.get(refFile) ?? [];
+		byRef.delete(refFile);
+		const failure = failures.get(file);
+		if (failure !== void 0) fileDiagnostics.push({
+			code: "extract-parse-error",
+			severity: "error",
+			message: `Cannot transform ${refFile} through the Vite config: ${failure}`,
+			file: refFile
+		});
+		const occurrences = [...(collected.modules.get(toPosix(file)) ?? /* @__PURE__ */ new Map()).entries()].sort(([a], [b]) => (a.includes("?") ? 1 : 0) - (b.includes("?") ? 1 : 0) || (a < b ? -1 : a > b ? 1 : 0)).flatMap(([, messages]) => [...messages]);
+		files.push({
+			file,
+			refFile,
+			occurrences,
+			diagnostics: fileDiagnostics,
+			fromCache: false
+		});
+		diagnostics.push(...fileDiagnostics);
+	}
+	for (const rest of byRef.values()) diagnostics.push(...rest);
+	return {
+		files,
+		messages: aggregateOccurrences(files.flatMap((scan) => scan.occurrences)),
+		diagnostics,
+		aborted: diagnostics.some((diagnostic) => ABORT_CODES.has(diagnostic.code))
+	};
+}
+const VITE_CONFIGS = [
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.ts",
+	"vite.config.cjs",
+	"vite.config.mts",
+	"vite.config.cts"
+];
+/** Vite's own lookup, from the vi18n config's root instead of the process's directory. */
+function viteConfigFile(root) {
+	for (const name of VITE_CONFIGS) {
+		const file = join(root, name);
+		if (existsSync(file)) return file;
+	}
+	return false;
+}
+function failedScan(leading, message) {
+	const diagnostics = [...leading, {
+		code: "extract-parse-error",
+		severity: "error",
+		message
+	}];
+	return {
+		files: [],
+		messages: /* @__PURE__ */ new Map(),
+		diagnostics,
+		aborted: true
+	};
+}
+//#endregion
+export { scanWithVite };

package/dist/vite.d.ts

@@ -0,0 +1,34 @@
+import { n as OutputOptions } from "./types-CgUCkFU1.js";
+import { Plugin, Rolldown } from "vite";
+//#region src/vite/types.d.ts
+/** Options of `vi18n()`. Everything else comes from `vi18n.config.ts`. */
+interface Vi18nPluginOptions {
+  /** Path of the config file, relative to the Vite root. Default: search upward for `vi18n.config.ts`. */
+  config?: string;
+  /** Build-only overrides, merged over the config's `output`. */
+  output?: OutputOptions;
+  /**
+   * Removed before 1.0: `vi18n()` adds its own plugins to Vite's
+   * `worker.plugins` (INTERNALS §2.9.9), so a worker build needs no second
+   * instance. `true` is rejected with `config-invalid` naming that.
+   */
+  worker?: boolean;
+}
+/** Options of `vi18nTransform()`, the call rewrite alone for Rollup/Rolldown pipelines (Nitro). */
+interface Vi18nTransformOptions {
+  config?: string;
+  /** Default `"build"` (ids only). */
+  mode?: "dev" | "build";
+}
+//#endregion
+//#region src/vite/index.d.ts
+export declare function vi18n(options?: Vi18nPluginOptions): Plugin[];
+/**
+ * The extraction rewrite for a plain Rollup/Rolldown build (§2.8.3, last
+ * paragraph): steps 1–6 in `build` mode (ids) unless `mode: "dev"`, without
+ * the boot import and the store. Such code runs in a process where the
+ * Vite-built server bundle or `registerCatalogs` registered catalogs.
+ */
+export declare function vi18nTransform(options?: Vi18nTransformOptions): Rolldown.Plugin;
+//#endregion
+export { type Vi18nPluginOptions, type Vi18nTransformOptions, vi18n as default };