@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/engine-B7p40M__.js

@@ -0,0 +1,531 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { r as validateTranslation } from "./validate-BxpupdAf.js";
+import { m as updateCatalogFile, s as catalogPath } from "./library-D5CWvTQs.js";
+import { i as listProjectFiles, r as isIncluded } from "./project-pXipT8iG.js";
+import { t as VERSION } from "./version-BlyLGlOa.js";
+import { i as rootRelative, r as plural } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, i as hasErrors, n as compareText, o as loadProject } from "./project-Dwx7iPm6.js";
+import { _ as toManualId, a as encodeMarkup, d as positionOf, i as atomicWrite, l as planCatalogs, t as MESSAGES_MODULE, u as plannedCatalog, v as usage } from "./migrate-dPgq9uzy.js";
+import { f as jsString, n as RUNTIME_MODULE, r as renderPlan } from "./rewrite-CiTRAICl.js";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+//#region src/cli/commands/migrate/engine.ts
+/**
+* `vi18n migrate --from i18next | react-intl | lingui | vue-i18n` (INTERNALS
+* §2.14, PLAN §5.19): the driver every library adapter shares.
+*
+* 1. `--catalog` files and directories become locale catalogs (the locale
+*    read from the path where no `<locale>=` names it); the adapter reads
+*    them and converts each text to ICU, keeping what it cannot convert;
+* 2. the adapter plans each file under `project.include`: call sites become
+*    edits rendered later, and what it cannot rewrite is reported (keys a
+*    reported site names go to a `msg()` table, so no translation is lost);
+* 3. every used message gets an id: a content id (the text is the message),
+*    unless two messages share a text but not their translations, or
+*    `--keep-ids` keeps a developer-chosen key: then a manual id;
+* 4. edits are rendered, imports added, and the vi18n catalogs planned the
+*    way `--from saas-i18n` does (add-only; existing translations win).
+*
+* Without `--write` nothing is written; any error writes nothing.
+*/
+const LOCALE_LIKE = /^[a-z]{2,3}(?:[-_][A-Za-z0-9]{2,8})*$/i;
+function normalizeLocale(name) {
+	return name.replace(/_/g, "-").toLowerCase();
+}
+/** The configured locale a path names (basename first, then directories, nearest first). */
+function localeOfPath(path, locales) {
+	const byName = new Map(locales.map((l) => [normalizeLocale(l), l]));
+	const parts = path.split(/[\\/]/).filter((p) => p !== "");
+	const base = (parts.pop() ?? "").replace(/\.[^.]+$/, "");
+	const baseLocale = byName.get(normalizeLocale(base));
+	if (baseLocale !== void 0) return {
+		locale: baseLocale,
+		fromDirectory: false
+	};
+	let unknown = LOCALE_LIKE.test(base) && base.length <= 3 ? base : null;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const part = parts[i];
+		const locale = byName.get(normalizeLocale(part));
+		if (locale !== void 0) return {
+			locale,
+			fromDirectory: true
+		};
+		if (unknown === null && LOCALE_LIKE.test(part) && part.length <= 5 && /^[a-z]/.test(part)) unknown = part;
+	}
+	return unknown === null ? null : { unknown };
+}
+async function listFiles(dir, extensions) {
+	const out = [];
+	const walk = async (current, depth) => {
+		if (depth > 6) return;
+		const entries = await readdir(current, { withFileTypes: true });
+		for (const entry of entries.sort((a, b) => compareText(a.name, b.name))) {
+			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const path = join(current, entry.name);
+			if (entry.isDirectory()) await walk(path, depth + 1);
+			else if (extensions.includes(extname(entry.name).toLowerCase())) out.push(path);
+		}
+	};
+	await walk(dir, 0);
+	return out;
+}
+/** `--catalog` entries as files with locales (and i18next namespaces). */
+async function resolveCatalogFiles(cwd, config, entries, extensions, env) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (file) => {
+		if (seen.has(file.file)) return;
+		seen.add(file.file);
+		out.push(file);
+	};
+	const configured = (locale) => {
+		const match = config.locales.find((l) => normalizeLocale(l) === normalizeLocale(locale));
+		if (match === void 0) throw usage(`--catalog ${locale}=…: ${locale} is not a configured locale (${config.locales.join(", ")})`);
+		return match;
+	};
+	for (const [index, entry] of entries.entries()) {
+		const path = resolve(cwd, entry.file);
+		let info;
+		try {
+			info = await stat(path);
+		} catch (error) {
+			throw usage(`--catalog ${entry.file}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (info.isDirectory()) {
+			const files = await listFiles(path, extensions);
+			if (files.length === 0) throw usage(`--catalog ${entry.file}: no ${extensions.join(", ")} files in it`);
+			for (const file of files) {
+				if (entry.locale !== null) {
+					add({
+						locale: configured(entry.locale),
+						file,
+						namespace: basename(file, extname(file))
+					});
+					continue;
+				}
+				const found = localeOfPath(relative(path, file), config.locales);
+				if (found !== null && "locale" in found) add({
+					locale: found.locale,
+					file,
+					namespace: found.fromDirectory ? basename(file, extname(file)) : null
+				});
+				else env.report("migrate-manual", found === null ? `${env.rel(file)} names no configured locale and was not read; pass it as --catalog <locale>=<file>` : `${env.rel(file)} is a ${found.unknown} catalog, which is not a configured locale: its translations were not migrated (add ${found.unknown} to locales and run again)`, { file });
+			}
+			continue;
+		}
+		if (entry.locale !== null) {
+			add({
+				locale: configured(entry.locale),
+				file: path,
+				namespace: null
+			});
+			continue;
+		}
+		const found = localeOfPath(relative(cwd, path), config.locales);
+		if (found !== null && "locale" in found) add({
+			locale: found.locale,
+			file: path,
+			namespace: found.fromDirectory ? basename(path, extname(path)) : null
+		});
+		else if (index === 0) add({
+			locale: config.sourceLocale,
+			file: path,
+			namespace: null
+		});
+		else throw usage(`--catalog ${entry.file}: the path names no configured locale; write <locale>=${entry.file}`);
+	}
+	return out;
+}
+/** Lowercase words of a text, for a readable manual id segment. */
+function slug(text, max = 32) {
+	const words = text.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().match(/[a-z0-9]+/g);
+	if (words === null) return "";
+	let out = "";
+	for (const word of words) {
+		const next = out === "" ? word : `${out}_${word}`;
+		if (next.length > max) break;
+		out = next;
+	}
+	return out || words[0].slice(0, max);
+}
+/** Whether merging these messages into one content id would drop a translation. */
+function translationsDiffer(group) {
+	const locales = new Set(group.flatMap((d) => [...d.translations.keys()]));
+	for (const locale of locales) {
+		const texts = /* @__PURE__ */ new Set();
+		for (const def of group) {
+			const translated = def.translations.get(locale);
+			if (translated === void 0) continue;
+			texts.add("icu" in translated ? translated.icu : `\0${translated.unconverted}`);
+		}
+		if (texts.size > 1) return true;
+	}
+	return false;
+}
+function assignIds(keys, defs, keepIds, codec) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const def = defs.get(key);
+		if (def === void 0) continue;
+		let group = groups.get(def.canonical);
+		if (group === void 0) groups.set(def.canonical, group = []);
+		group.push(def);
+	}
+	const ids = /* @__PURE__ */ new Map();
+	const reasons = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	const pending = [];
+	for (const group of groups.values()) {
+		const conflict = group.length > 1 && translationsDiffer(group);
+		for (const def of group) if (conflict) {
+			reasons.set(def.key, "same text as another message, other translations");
+			pending.push(def);
+		} else if (keepIds && def.named) {
+			reasons.set(def.key, "--keep-ids");
+			pending.push(def);
+		} else ids.set(def.key, {
+			id: codec.label(def.canonical),
+			manual: false
+		});
+	}
+	const base = (def) => def.named ? toManualId(def.key.replace(/:/g, ".")) : toManualId(`${slug(def.hint ?? def.context ?? "") || "msg"}.${slug(def.source) || "message"}`);
+	for (const def of pending) {
+		const id = base(def);
+		if (def.named && id === def.key) taken.add(id);
+	}
+	for (const def of pending.sort((a, b) => compareText(a.key, b.key))) {
+		let id = base(def);
+		if (!(def.named && id === def.key)) {
+			if (taken.has(id)) {
+				let n = 2;
+				while (taken.has(`${id}_${n}`)) n++;
+				id = `${id}_${n}`;
+			}
+			taken.add(id);
+		}
+		ids.set(def.key, {
+			id,
+			manual: true
+		});
+	}
+	return {
+		ids,
+		reasons
+	};
+}
+async function createAdapter(library) {
+	switch (library) {
+		case "i18next": return (await import("./i18next-Rgo-v9l0.js")).createI18nextAdapter();
+		case "react-intl": return (await import("./react-intl-CaBVwJ9u.js")).createReactIntlAdapter();
+		case "lingui": return (await import("./lingui--PcOOYry.js")).createLinguiAdapter();
+		case "vue-i18n": return (await import("./vue-i18n-CEMnpv7k.js")).createVueI18nAdapter();
+	}
+}
+/** Where the `msg()` table goes: beside the source catalog when that is extracted, else in the first include root. */
+function messagesPath(config, files) {
+	const source = files.find((f) => f.locale === config.sourceLocale);
+	if (source !== void 0) {
+		const beside = join(dirname(source.file), MESSAGES_MODULE);
+		if (isIncluded(beside, config)) return beside;
+	}
+	return join(config.project.include[0] ?? config.root, MESSAGES_MODULE);
+}
+async function migrateLibrary(ctx, flags) {
+	const library = flags.from;
+	const project = await loadProject(ctx);
+	const { config, codec } = project;
+	const rel = (file) => rootRelative(config.root, file);
+	const diagnostics = [];
+	const defs = /* @__PURE__ */ new Map();
+	const failed = /* @__PURE__ */ new Set();
+	const env = {
+		config,
+		codec,
+		library,
+		rel,
+		diagnostics,
+		define(def) {
+			if (defs.has(def.key)) return true;
+			if (failed.has(def.key)) return false;
+			try {
+				defs.set(def.key, {
+					...def,
+					canonical: codec.canonicalize(def.source)
+				});
+				return true;
+			} catch (error) {
+				if (!isDiagnosticError(error)) throw error;
+				failed.add(def.key);
+				diagnostics.push({
+					code: "migrate-unconverted",
+					severity: "warning",
+					message: `${def.key}: the source text is not valid ICU after conversion (${error.diagnostic.message}); its call sites were not rewritten: ${JSON.stringify(def.source)}`,
+					file: rel(def.file),
+					...def.line > 0 ? { line: def.line } : {},
+					id: def.key
+				});
+				return false;
+			}
+		},
+		message: (key) => defs.get(key),
+		report(code, message, at, severity = "warning") {
+			const diagnostic = {
+				code,
+				severity,
+				message,
+				file: rel(at.file)
+			};
+			if (at.text !== void 0 && at.offset !== void 0) Object.assign(diagnostic, positionOf(at.text, at.offset));
+			else if (at.line !== void 0 && at.line > 0) diagnostic.line = at.line;
+			diagnostics.push(diagnostic);
+		}
+	};
+	const adapter = await createAdapter(library);
+	const data = {
+		from: library,
+		write: flags.write,
+		files: [],
+		rewritten: 0,
+		renamed: [],
+		manualIds: [],
+		messagesModule: null,
+		entries: {},
+		edits: [],
+		unused: []
+	};
+	const catalogFiles = await resolveCatalogFiles(ctx.global.cwd, config, flags.catalogs, adapter.catalogExtensions, env);
+	if (adapter.catalogsRequired && !catalogFiles.some((f) => f.locale === config.sourceLocale)) throw usage(`--catalog: no ${config.sourceLocale} catalog found; ${library} keeps the source text in the catalog of the source locale (${config.sourceLocale})`);
+	adapter.load(catalogFiles, env);
+	const table = messagesPath(config, catalogFiles);
+	const skip = /* @__PURE__ */ new Set([table, ...catalogFiles.map((f) => f.file)]);
+	const listed = await listProjectFiles(config);
+	const plans = [];
+	for (const file of listed.files.slice().sort(compareText)) {
+		if (skip.has(file)) continue;
+		const text = await readFile(file, "utf8");
+		if (!adapter.mentions(text)) continue;
+		if (!adapter.extensions.has(extname(file))) {
+			env.report("migrate-manual", `uses ${library}, but ${extname(file)} files are not rewritten by vi18n migrate --from ${library}: convert it by hand`, { file });
+			continue;
+		}
+		const plan = adapter.planFile(file, text, env);
+		if (plan !== null && (plan.edits.length > 0 || plan.manual.length > 0)) plans.push(plan);
+	}
+	const used = /* @__PURE__ */ new Map();
+	const use = (key, file) => {
+		let files = used.get(key);
+		if (files === void 0) used.set(key, files = /* @__PURE__ */ new Set());
+		files.add(rel(file));
+	};
+	const dynamicKeys = /* @__PURE__ */ new Set();
+	for (const plan of plans) {
+		for (const key of renderPlan(plan, () => "").used) use(key, plan.file);
+		for (const site of plan.manual) {
+			const where = positionOf(plan.text, site.offset);
+			const keys = site.keys.filter((key) => defs.has(key));
+			for (const key of keys) {
+				dynamicKeys.add(key);
+				use(key, table);
+			}
+			const sorted = [...new Set(keys)].sort(compareText);
+			const example = sorted.slice(0, 3).join(", ") + (sorted.length > 3 ? ", …" : "");
+			diagnostics.push({
+				code: keys.length > 0 ? "migrate-dynamic-key" : "migrate-manual",
+				severity: "warning",
+				message: keys.length > 0 ? `${site.message}; ${plural(sorted.length, "message")} (${example}) ${sorted.length === 1 ? "is a msg() descriptor" : "are msg() descriptors"} in ${rel(table)}: import { messages } from it and call t(messages[key])` : site.message,
+				file: rel(plan.file),
+				line: where.line,
+				column: where.column
+			});
+		}
+	}
+	const usedKeys = [...used.keys()].sort(compareText);
+	const { ids, reasons } = assignIds(usedKeys, defs, flags.keepIds, codec);
+	data.unused.push(...adapter.unusedKeys());
+	data.unused.sort(compareText);
+	for (const key of usedKeys) {
+		const assigned = ids.get(key);
+		if (assigned?.manual === true) data.manualIds.push({
+			key,
+			id: assigned.id,
+			reason: reasons.get(key) ?? ""
+		});
+	}
+	const describe = (key, quote, markup) => {
+		const def = defs.get(key);
+		const assigned = ids.get(key);
+		const parts = [];
+		if (assigned.manual) parts.push(`id: ${jsString(assigned.id, quote)}`);
+		parts.push(`message: ${jsString(def.canonical, quote)}`);
+		if (def.context !== null) parts.push(`context: ${jsString(def.context, quote)}`);
+		const code = parts.length === 1 ? jsString(def.canonical, quote) : `{ ${parts.join(", ")} }`;
+		return encodeMarkup(code, markup);
+	};
+	const outputs = [];
+	for (const plan of plans) {
+		if (plan.edits.length === 0) continue;
+		const rendered = renderPlan(plan, describe);
+		for (const edit of rendered.listed) {
+			const where = positionOf(plan.text, edit.start);
+			data.edits.push({
+				file: rel(plan.file),
+				line: where.line,
+				column: where.column,
+				from: edit.from,
+				to: edit.to
+			});
+		}
+		data.rewritten += rendered.rewritten;
+		if (rendered.text !== plan.text) outputs.push({
+			file: plan.file,
+			text: rendered.text
+		});
+	}
+	if (dynamicKeys.size > 0) {
+		outputs.push({
+			file: table,
+			text: messagesModule(library, [...dynamicKeys], defs, describe)
+		});
+		data.messagesModule = rel(table);
+		if (!isIncluded(table, config)) diagnostics.push({
+			code: "extract-outside-include",
+			severity: "warning",
+			message: `${rel(table)} is outside project.include, so vi18n extract will not see its msg() descriptors; add its directory to project.include`,
+			file: rel(table)
+		});
+	}
+	const messages = /* @__PURE__ */ new Map();
+	const translations = /* @__PURE__ */ new Map();
+	const notes = /* @__PURE__ */ new Map();
+	for (const key of usedKeys) {
+		const def = defs.get(key);
+		const assigned = ids.get(key);
+		const refs = [...used.get(key) ?? []];
+		const existing = messages.get(assigned.id);
+		if (existing === void 0) messages.set(assigned.id, {
+			id: assigned.id,
+			manual: assigned.manual,
+			canonical: def.canonical,
+			sourceHash: codec.sourceHash(def.canonical),
+			label: codec.label(def.canonical),
+			contexts: def.context === null ? [] : [def.context],
+			refs: refs.sort(compareText),
+			sources: [def.canonical],
+			locations: []
+		});
+		else {
+			existing.refs = [.../* @__PURE__ */ new Set([...existing.refs, ...refs])].sort(compareText);
+			if (def.context !== null && !existing.contexts.includes(def.context)) existing.contexts = [...existing.contexts, def.context].sort(compareText);
+		}
+		for (const [locale, translated] of def.translations) {
+			if (locale === config.sourceLocale || !config.locales.includes(locale)) continue;
+			if ("icu" in translated) {
+				let map = translations.get(locale);
+				if (map === void 0) translations.set(locale, map = /* @__PURE__ */ new Map());
+				if (map.has(assigned.id)) continue;
+				map.set(assigned.id, translated.icu);
+				diagnostics.push(...translationProblems(codec, def, locale, translated.icu, assigned.id, rel));
+			} else {
+				let map = notes.get(locale);
+				if (map === void 0) notes.set(locale, map = /* @__PURE__ */ new Map());
+				const note = `vi18n migrate: ${library} text not converted (${translated.reason}): ${translated.unconverted.replace(/\r?\n/g, "\\n")}`;
+				map.set(assigned.id, [...map.get(assigned.id) ?? [], note]);
+				diagnostics.push({
+					code: "migrate-unconverted",
+					severity: "warning",
+					message: `${def.key} (${locale}): ${translated.reason}; the entry stays untranslated with the original as a translator comment: ${JSON.stringify(translated.unconverted)}`,
+					file: rel(translated.file ?? def.file),
+					...translated.file !== void 0 && (translated.line ?? 0) > 0 ? { line: translated.line } : {},
+					locale,
+					id: assigned.id
+				});
+			}
+		}
+	}
+	const loaded = await loadCatalogs(project);
+	diagnostics.push(...loaded.diagnostics.filter((d) => d.code === "catalog-parse" && d.severity === "error"));
+	const catalogPlans = planCatalogs(project, loaded.set, messages, translations, notes);
+	diagnostics.push(...catalogPlans.diagnostics);
+	for (const [locale, count] of catalogPlans.counts) if (locale !== config.sourceLocale) data.entries[locale] = count;
+	ctx.out.report(diagnostics);
+	const failedRun = hasErrors(diagnostics);
+	data.files = [...outputs.map((o) => rel(o.file)), ...catalogPlans.changed.map((locale) => rel(catalogPath(config, locale)))];
+	if (flags.write && !failedRun) {
+		for (const output of outputs) await atomicWrite(output.file, output.text);
+		for (const locale of catalogPlans.changed) await updateCatalogFile(catalogPath(config, locale), loaded.set.get(locale)?.hash ?? null, (current) => plannedCatalog(project, locale, current, catalogPlans.sourceCatalog, messages, translations.get(locale), notes.get(locale)).catalog, {
+			locale,
+			layout: project.layout,
+			isSourceLocale: locale === config.sourceLocale,
+			version: VERSION
+		});
+	}
+	printPlan(ctx, data, failedRun);
+	return {
+		exitCode: failedRun ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+/** A translation that does not fit its source is still written (people fix it), but reported now. */
+function translationProblems(codec, def, locale, translation, id, rel) {
+	const at = {
+		file: rel(def.file),
+		locale,
+		id
+	};
+	try {
+		return validateTranslation(codec.parse(translation), codec.parse(def.canonical), {
+			locale,
+			text: translation
+		}).filter((d) => d.severity === "error").map((d) => ({
+			...d,
+			...at,
+			code: "catalog-invalid-translation",
+			severity: "warning",
+			message: `${def.key} (${locale}): ${d.message}`
+		}));
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		return [{
+			...error.diagnostic,
+			...at,
+			severity: "warning",
+			message: `${def.key} (${locale}): ${error.diagnostic.message}`
+		}];
+	}
+}
+/** `export const messages = { "<key>": msg(…) }`, keyed by the old library's key the code computes. */
+function messagesModule(library, keys, defs, describe) {
+	const lines = [
+		`// Generated by vi18n migrate --from ${library}: messages the code looks up by a`,
+		"// computed key, or at call sites vi18n migrate left for a person, as msg()",
+		"// descriptors so vi18n extract keeps them. Look one up with t(messages[key]).",
+		`import { msg } from "${RUNTIME_MODULE}";`,
+		"",
+		"export const messages = {"
+	];
+	for (const key of [...new Set(keys)].sort(compareText)) {
+		if (!defs.has(key)) continue;
+		lines.push(`  ${JSON.stringify(key)}: msg(${describe(key, "\"", null)}),`);
+	}
+	lines.push("} as const;", "");
+	return lines.join("\n");
+}
+function printPlan(ctx, data, failed) {
+	const indent = (text) => text.replace(/\n/g, "\n    ");
+	for (const edit of data.edits) {
+		const lines = [`${edit.file}:${edit.line}:${edit.column}`];
+		const show = (text) => indent(text.replace(/^[ \t]+/, "").replace(/\n$/, ""));
+		if (edit.from !== "") lines.push(`  - ${show(edit.from)}`);
+		if (edit.to !== "") lines.push(`  + ${show(edit.to)}`);
+		ctx.out.result(lines.join("\n"));
+	}
+	if (data.manualIds.length > 0) ctx.out.result(`manual ids: ${data.manualIds.map((m) => `${m.key} → ${m.id} (${m.reason})`).join(", ")}`);
+	if (data.messagesModule !== null) ctx.out.result(`msg() table: ${data.messagesModule}`);
+	for (const [locale, count] of Object.entries(data.entries)) ctx.out.result(`${locale}: ${plural(count, "translation")} for the vi18n catalog`);
+	if (data.unused.length > 0) ctx.out.result(`${plural(data.unused.length, "catalog key")} no code uses: ${data.unused.join(", ")}`);
+	const verb = data.write && !failed ? "rewrote" : "would rewrite";
+	ctx.out.result(`${verb} ${plural(data.rewritten, "call")} in ${plural(data.files.length, "file")}` + (data.write ? failed ? " (nothing written: fix the errors first)" : "" : "; run with --write to apply"));
+}
+//#endregion
+export { migrateLibrary };

package/dist/engine.d.ts

@@ -0,0 +1,43 @@
+import "./types-DsdWBG0b.js";
+//#region src/runtime/devtools.d.ts
+/** The part of `import.meta.hot` the editor uses. */
+interface DevHot {
+  on(event: string, listener: (data: never) => void): void;
+  send(event: string, data?: unknown): void;
+}
+/**
+ * Installs the editor on the page: the `seen` recorder on the page scope,
+ * the Alt+click listener, the HMR reply listener and the dock's bridge.
+ * Called by the plugin's dev client boot (`devtools: true`) with its
+ * `import.meta.hot`; a no-op outside a document or without HMR.
+ */
+export declare function inContext(hot: DevHot | undefined, endpoint: string): void;
+//#endregion
+//#region src/runtime/loader.d.ts
+/**
+ * The client engine behind the global state (INTERNALS §2.11): registration,
+ * bundle loading, skew handling, locale switching, the navigation watcher,
+ * the `fetch` wrapper and persistence. Only `@menapo/vi18n/engine` imports
+ * it, and the generated client boot module imports that entry first; it
+ * hooks into the core's `register` and replaces the inert client methods
+ * `state.ts` installs, so neither the `.` entry nor `/server` carries it.
+ *
+ * Its data is private to the runtime copy that created the state; every
+ * public export reaches it through the state's methods, so a second copy never
+ * reads its own empty variables. Module-level variables rather than one
+ * object, and one-letter fields on `LocaleData`: the minifier renames
+ * variables but never properties, and this file is most of the engine's
+ * 3.5 KB budget (PLAN §6).
+ */
+/**
+ * The creating side of the bridge: `virtual:vi18n/bridge` calls it in every
+ * realm whose code constructs a worker (a page, or a worker that starts its
+ * own). Each `new Worker(url)` gets the realm's locale as a URL fragment,
+ * which leaves the request alone; a worker that answers with a hello is told
+ * the version and map, then every locale this realm flips to. Workers that
+ * never say hello (no vi18n in them, or `type: "classic"` scripts the
+ * fragment does not reach) never hear from it.
+ */
+export declare function bridge(): void;
+//#endregion
+export {};