@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/check-D34P-S--.js

@@ -0,0 +1 @@
+export { t as check } from "./check-DyrAbv73.js";

package/dist/check-DyrAbv73.js

@@ -0,0 +1,201 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { r as validateTranslation } from "./validate-BxpupdAf.js";
+import { s as catalogPath } from "./library-D5CWvTQs.js";
+import { r as resolveDuplicates, t as duplicateDiagnostics } from "./duplicates-yuRljQ6h.js";
+import { t as findCollisions } from "./collisions-CfpZU8e4.js";
+import { i as rootRelative, r as plural, t as countBySeverity } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, c as ownStatus, d as referencedMessages, f as scan, o as loadProject, s as occurrencesOf } from "./project-Dwx7iPm6.js";
+//#region src/cli/commands/check.ts
+/**
+* `vi18n check [missing] [placeholders] [syntax] [--ci] [--format …]`
+* (INTERNALS §2.14, PLAN §4.14): validation of the catalogs against the
+* code, with GitHub annotations at the catalog line. Exit 1 on errors, and
+* with `--ci` on warnings of the selected categories too.
+*
+* - syntax: catalogs that do not parse, invalid sources and translations,
+*   wrapped lines, duplicates, foreign contexts, collisions, id-scheme drift,
+*   and the code's own extraction errors;
+* - placeholders: everything `validateTranslation` finds in a translation
+*   (argument and tag mismatches, plural categories, length, apostrophes);
+* - missing: referenced messages without a usable own translation per target
+*   locale, fuzzy and invalid ones included.
+*/
+const ALL = [
+	"missing",
+	"placeholders",
+	"syntax"
+];
+/** Missing ids named in each locale's summary; the count says how many more there are. */
+const MISSING_LISTED = 20;
+/** Scan findings that belong to `check syntax`: invalid source messages, and anything the build would fail on. */
+function isSyntaxFinding(diagnostic) {
+	return diagnostic.severity === "error" || diagnostic.code.startsWith("icu-");
+}
+async function check(ctx, flags) {
+	const categories = flags.categories.length === 0 ? ALL.slice() : flags.categories;
+	const project = await loadProject(ctx);
+	const { config } = project;
+	const found = {
+		missing: [],
+		placeholders: [],
+		syntax: []
+	};
+	const scanned = await scan(project);
+	const loaded = await loadCatalogs(project);
+	const referenced = referencedMessages(project, scanned.messages, loaded.set);
+	if (categories.includes("syntax")) {
+		found.syntax.push(...scanned.diagnostics.filter(isSyntaxFinding));
+		found.syntax.push(...loaded.diagnostics);
+		found.syntax.push(...referenced.diagnostics);
+		found.syntax.push(...findCollisions(occurrencesOf(scanned), loaded.set, project.codec, { referenced: new Set(config.extraction.keep) }));
+	}
+	for (const locale of config.locales) {
+		const catalog = loaded.set.get(locale);
+		const file = rootRelative(config.root, catalog?.path ?? catalogPath(config, locale));
+		const read = catalog?.catalog ?? null;
+		if (categories.includes("syntax") && read !== null) {
+			for (const entry of read.entries) syntaxOfEntry(found.syntax, entry, file, locale);
+			found.syntax.push(...duplicateDiagnostics(resolveDuplicates(read, project.codec).duplicates, file));
+			if (read.header.idScheme !== null && read.header.idScheme !== project.codec.idScheme) found.syntax.push({
+				code: "id-scheme-mismatch",
+				severity: "error",
+				message: `${file} records ${read.header.idScheme}, but ids.length ${config.ids.length} gives ${project.codec.idScheme}; run vi18n extract to re-key it`,
+				file,
+				locale
+			});
+		}
+		if (locale === config.sourceLocale) continue;
+		const status = ownStatus(project, locale, catalog, referenced.identities);
+		const findings = translationFindings(project, status, referenced.identities, file);
+		if (categories.includes("syntax")) found.syntax.push(...findings.syntax);
+		if (categories.includes("placeholders")) found.placeholders.push(...findings.placeholders);
+		if (categories.includes("missing")) found.missing.push(...missing(project, status, file));
+	}
+	const data = {
+		categories,
+		counts: {}
+	};
+	let failed = false;
+	for (const category of categories) {
+		const list = found[category];
+		ctx.out.report(list);
+		const counts = countBySeverity(list);
+		data.counts[category] = counts;
+		if (counts.error > 0 || flags.ci && counts.warning > 0) failed = true;
+	}
+	ctx.out.result(categories.map((category) => {
+		const counts = data.counts[category];
+		return `${category}: ${plural(counts.error, "error")}, ${plural(counts.warning, "warning")}`;
+	}).join("; "));
+	return {
+		exitCode: failed ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+/** Wrapped lines and foreign contexts; the language server reports them on open catalogs too. */
+function syntaxOfEntry(into, entry, file, locale) {
+	if (entry.wrapped) into.push({
+		code: "catalog-wrapped",
+		severity: "warning",
+		message: "a string is wrapped over several lines; vi18n extract rewrites it on one line",
+		file,
+		line: entry.line,
+		locale
+	});
+	if (entry.foreignContext !== null) into.push({
+		code: "catalog-foreign-context",
+		severity: "warning",
+		message: `msgctxt "${entry.foreignContext}" is not a manual id (no "."), so no message matches this entry; give it a manual id with a "." or remove it`,
+		file,
+		line: entry.line,
+		locale
+	});
+}
+/**
+* Every referenced entry with a translation whose source still matches:
+* a translation that does not parse is a syntax finding; otherwise every
+* finding of `validateTranslation` is a placeholders finding
+* (`usableTranslation` keeps only errors, `check` also reports the warnings:
+* plural categories, `maxLength`, apostrophes). Located at the entry's line,
+* since positions inside the text mean nothing in a catalog.
+*/
+function translationFindings(project, status, identities, file) {
+	const { codec } = project;
+	const out = {
+		syntax: [],
+		placeholders: []
+	};
+	const at = (diagnostic, id, entry) => {
+		const located = {
+			...diagnostic,
+			file,
+			locale: status.locale,
+			id
+		};
+		if (entry.line > 0) located.line = entry.line;
+		else delete located.line;
+		delete located.column;
+		return located;
+	};
+	for (const [id, entry] of status.entries) {
+		if (entry.translation === "") continue;
+		const reason = status.reasons.get(id);
+		if (reason === "source-mismatch" || reason === "scheme-mismatch") continue;
+		const identity = identities.get(id);
+		let parsed;
+		try {
+			parsed = codec.parse(entry.translation);
+		} catch (error) {
+			if (!isDiagnosticError(error)) throw error;
+			out.syntax.push(at(error.diagnostic, id, entry));
+			continue;
+		}
+		const options = {
+			locale: status.locale,
+			text: entry.translation
+		};
+		if (entry.maxLength !== null) options.maxLength = entry.maxLength;
+		for (const diagnostic of validateTranslation(parsed, codec.parse(identity.canonical), options)) out.placeholders.push(at(diagnostic, id, entry));
+	}
+	return out;
+}
+function missing(project, status, file) {
+	const level = project.config.strict.missing;
+	if (level === "off" || status.missing === 0) return [];
+	const severity = level === "error" ? "error" : "warning";
+	const out = [];
+	const ids = [];
+	let fuzzy = 0;
+	let invalid = 0;
+	for (const [id, reason] of status.reasons) {
+		if (ids.length < MISSING_LISTED) ids.push(id);
+		if (reason === "fuzzy") {
+			fuzzy++;
+			const entry = status.entries.get(id);
+			const diagnostic = {
+				code: "catalog-fuzzy",
+				severity,
+				message: `${id} is marked fuzzy, so its translation is not used; review it and remove the fuzzy flag`,
+				file,
+				locale: status.locale,
+				id
+			};
+			if (entry.line > 0) diagnostic.line = entry.line;
+			out.push(diagnostic);
+		} else if (reason === "invalid") invalid++;
+	}
+	const extra = [];
+	if (fuzzy > 0) extra.push(`${fuzzy} fuzzy`);
+	if (invalid > 0) extra.push(`${invalid} invalid`);
+	out.unshift({
+		code: "catalog-missing-translation",
+		severity,
+		message: `${status.locale} lacks a usable translation for ${status.missing} of ${status.total} messages${extra.length > 0 ? ` (${extra.join(", ")})` : ""}: ${ids.join(", ")}${status.missing > ids.length ? ", …" : ""}; run vi18n translate or edit ${file}`,
+		file,
+		locale: status.locale
+	});
+	return out;
+}
+//#endregion
+export { syntaxOfEntry as n, check as t };

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { t as run } from "./run-DYD_VXKy.js";
+import { createInterface } from "node:readline/promises";
+//#region src/cli/bin.ts
+/**
+* The `vi18n` binary (docs/INTERNALS.md §3.5). In the workspace this `.ts`
+* file runs with Node's type stripping; published, `dist/cli.js`. Everything
+* but the process wiring lives in `run.ts`, so tests drive the commands
+* in-process.
+*/
+const controller = new AbortController();
+process.once("SIGINT", () => {
+	controller.abort();
+	process.once("SIGINT", () => process.exit(130));
+});
+const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+process.exitCode = await run(process.argv.slice(2), {
+	cwd: process.cwd(),
+	env: process.env,
+	stdout: (text) => process.stdout.write(text),
+	stderr: (text) => process.stderr.write(text),
+	signal: controller.signal,
+	streams: {
+		input: process.stdin,
+		output: process.stdout
+	},
+	...interactive ? { async prompt(question, fallback) {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stderr
+		});
+		try {
+			const answer = await rl.question(`${question} (${fallback}): `);
+			return answer.trim() === "" ? fallback : answer.trim();
+		} finally {
+			rl.close();
+		}
+	} } : {}
+});
+//#endregion
+export {};

package/dist/codec-DuvU2VQy.js

@@ -0,0 +1,207 @@
+import { a as diagnosticError, o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { c as sourceHash, d as parseSource, i as idScheme, l as isPlainText, u as normalizeSource } from "./validate-BxpupdAf.js";
+//#region src/core/icu/print.ts
+const HASH = 35;
+const APOS = 39;
+const SLASH = 47;
+const LT = 60;
+const GT = 62;
+const LBRACE = 123;
+const RBRACE = 125;
+/** "Nothing follows": the end of the whole message. */
+const END = -1;
+/** Prints a message in canonical form. Literal text keeps every character. */
+function printICU(message) {
+	return printNodes(message, false, END);
+}
+/**
+* @param poundSensitive inside any plural/selectordinal option, where `#` must be quoted
+* @param after          first character printed after these nodes: `}` (option), `<` (closing tag) or END
+*/
+function printNodes(nodes, poundSensitive, after) {
+	let out = "";
+	const count = nodes.length;
+	for (let i = 0; i < count; i++) {
+		const node = nodes[i];
+		if (node.type === "literal") {
+			let value = node.value;
+			while (i + 1 < count && nodes[i + 1].type === "literal") value += nodes[++i].value;
+			const next = i + 1 < count ? firstChar(nodes[i + 1]) : after;
+			out += printLiteral(value, poundSensitive, next);
+			continue;
+		}
+		out += printNode(node, poundSensitive);
+	}
+	return out;
+}
+function printNode(node, poundSensitive) {
+	switch (node.type) {
+		case "literal": return printLiteral(node.value, poundSensitive, END);
+		case "argument": return `{${node.name}}`;
+		case "number":
+		case "date":
+		case "time": {
+			const style = node.style;
+			if (style === null) return `{${node.name}, ${node.type}}`;
+			return `{${node.name}, ${node.type}, ${style.kind === "skeleton" ? "::" + style.value : style.value}}`;
+		}
+		case "select": return `{${node.name}, select, ${printOptions(node.options, poundSensitive)}}`;
+		case "plural": {
+			const type = node.pluralType === "cardinal" ? "plural" : "selectordinal";
+			const offset = node.offset === 0 ? "" : `offset:${node.offset} `;
+			return `{${node.name}, ${type}, ${offset}${printOptions(node.options, true)}}`;
+		}
+		case "pound": return "#";
+		case "tag": return node.children === null ? `<${node.name}/>` : `<${node.name}>${printNodes(node.children, poundSensitive, LT)}</${node.name}>`;
+	}
+}
+function printOptions(options, poundSensitive) {
+	let out = "";
+	for (let i = 0; i < options.length; i++) {
+		const option = options[i];
+		if (i > 0) out += " ";
+		out += `${option.key} {${printNodes(option.value, poundSensitive, RBRACE)}}`;
+	}
+	return out;
+}
+function firstChar(node) {
+	switch (node.type) {
+		case "tag": return LT;
+		case "pound": return HASH;
+		case "literal": return node.value.charCodeAt(0);
+		default: return LBRACE;
+	}
+}
+/**
+* Minimal, deterministic quoting: a run starting at a special character
+* (`{`, `}`, `#` where pound-sensitive, `<` before a letter or `/`) is wrapped
+* in apostrophes together with any special characters and apostrophes that
+* follow it; any other apostrophe is doubled only where a single one would
+* open a quote.
+*/
+function printLiteral(value, poundSensitive, after) {
+	if (!needsQuoting(value, poundSensitive)) return value;
+	const length = value.length;
+	let out = "";
+	let run = 0;
+	let i = 0;
+	while (i < length) {
+		const c = value.charCodeAt(i);
+		if (isSpecial(value, i, c, poundSensitive)) {
+			let j = i + 1;
+			while (j < length) {
+				const d = value.charCodeAt(j);
+				if (d !== APOS && !isSpecial(value, j, d, poundSensitive)) break;
+				j++;
+			}
+			out += value.slice(run, i) + "'" + value.slice(i, j).replaceAll("'", "''") + "'";
+			i = j;
+			run = j;
+			continue;
+		}
+		if (c === APOS) {
+			const next = i + 1 < length ? value.charCodeAt(i + 1) : after;
+			if (next === APOS || next === LBRACE || next === RBRACE || next === LT || next === GT || next === HASH && poundSensitive) {
+				out += value.slice(run, i + 1) + "'";
+				run = i + 1;
+			}
+		}
+		i++;
+	}
+	return out + value.slice(run);
+}
+function needsQuoting(value, poundSensitive) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c === APOS || c === LBRACE || c === RBRACE || c === LT || c === HASH && poundSensitive) return true;
+	}
+	return false;
+}
+function isSpecial(value, i, c, poundSensitive) {
+	if (c === LBRACE || c === RBRACE) return true;
+	if (c === HASH) return poundSensitive;
+	if (c === LT) {
+		const next = value.charCodeAt(i + 1);
+		return next === SLASH || next >= 65 && next <= 90 || next >= 97 && next <= 122;
+	}
+	return false;
+}
+//#endregion
+//#region src/core/codec.ts
+/**
+* The one place that turns source text into ids (INTERNALS §2.2). Extract,
+* catalogs and compilation see the same message many times per run, so parses,
+* canonical forms and hashes are memoised per string.
+*/
+/**
+* Memo entries past this count are dropped all at once: a long dev session
+* sees every edit of every message, while one scan of a large project needs
+* the whole set warm.
+*/
+const MEMO_LIMIT = 2e5;
+function createCodec(idLength) {
+	if (!Number.isInteger(idLength) || idLength < 8 || idLength > 16) throw diagnosticError({
+		code: "config-invalid",
+		severity: "error",
+		message: `ids.length must be an integer from 8 to 16, not ${String(idLength)}`
+	});
+	const parsed = /* @__PURE__ */ new Map();
+	const hashes = /* @__PURE__ */ new Map();
+	const entry = (source) => {
+		let found = parsed.get(source);
+		if (found === void 0) {
+			found = {
+				ast: null,
+				error: null,
+				canonical: null
+			};
+			try {
+				const normalized = normalizeSource(source);
+				found.ast = isPlainText(normalized) ? normalized === "" ? [] : [{
+					type: "literal",
+					value: normalized
+				}] : parseSource(normalized);
+			} catch (error) {
+				if (!isDiagnosticError(error)) throw error;
+				found.error = error;
+			}
+			if (parsed.size >= MEMO_LIMIT) parsed.clear();
+			parsed.set(source, found);
+		}
+		return found;
+	};
+	const hashOf = (canonical) => {
+		let found = hashes.get(canonical);
+		if (found === void 0) {
+			found = sourceHash(canonical);
+			if (hashes.size >= MEMO_LIMIT) hashes.clear();
+			hashes.set(canonical, found);
+		}
+		return found;
+	};
+	return {
+		idLength,
+		idScheme: idScheme(idLength),
+		canonicalize(source) {
+			const found = parsed.get(source);
+			if (found === void 0) {
+				const normalized = normalizeSource(source);
+				if (isPlainText(normalized)) return normalized;
+			}
+			const memo = found ?? entry(source);
+			if (memo.error !== null) throw memo.error;
+			return memo.canonical ??= printICU(memo.ast);
+		},
+		parse(source) {
+			const memo = entry(source);
+			if (memo.error !== null) throw memo.error;
+			return memo.ast;
+		},
+		sourceHash: hashOf,
+		label(canonical) {
+			return hashOf(canonical).slice(0, idLength);
+		}
+	};
+}
+//#endregion
+export { printICU as n, createCodec as t };

package/dist/collect-Cx4_SKOe.js

@@ -0,0 +1,13 @@
+//#region src/core/extract/collect.ts
+const KEY = Symbol.for("@menapo/vi18n:extract-collector");
+/** The collector `vi18n extract --vite` set, or null outside it. */
+function activeCollector() {
+	return globalThis[KEY] ?? null;
+}
+/** Sets (or, with null, clears) the collector plugins created from now on report to. */
+function setCollector(collector) {
+	if (collector === null) delete globalThis[KEY];
+	else globalThis[KEY] = collector;
+}
+//#endregion
+export { setCollector as n, activeCollector as t };

package/dist/collisions-CfpZU8e4.js

@@ -0,0 +1,217 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { S as entryKey } from "./library-D5CWvTQs.js";
+import { r as resolveDuplicates } from "./duplicates-yuRljQ6h.js";
+//#region src/core/catalog/collisions.ts
+/**
+* Id collisions (PLAN §5.5, INTERNALS §2.6.7): two different texts behind one
+* id are a hard error, never resolved automatically, because any automatic
+* rule would make one message's id depend on another's existence. The check
+* covers the messages being compiled and every entry of the catalog set, so
+* apps sharing catalogs collide loudly instead of overwriting each other.
+*/
+const DELETED_HINT = "; if that message was deleted, run vi18n extract first";
+function posix(path) {
+	return path.replaceAll("\\", "/");
+}
+function where(file, line) {
+	return line > 0 ? `${file}:${line}` : file;
+}
+function messagePlace(message) {
+	const location = message.locations?.[0] ?? (message.file === void 0 ? void 0 : {
+		file: message.file,
+		line: message.line ?? 0
+	});
+	if (location === void 0) return { text: "" };
+	return {
+		file: location.file,
+		line: location.line,
+		text: ` (${where(location.file, location.line)})`
+	};
+}
+function canonicalOf(source, codec) {
+	try {
+		return codec.canonicalize(source);
+	} catch (error) {
+		if (isDiagnosticError(error)) return null;
+		throw error;
+	}
+}
+/**
+* Canonical text → where it was first seen, per generated key. Only entries
+* whose source hashes to their key take part: in the `"id"` layout and JSON a
+* hand-edited or stripped source note is a stale entry (reported as a source
+* mismatch elsewhere), not a second text behind the id, and a file still on
+* another id length would match nothing anyway. PLAN §5.5 makes a collision
+* two live texts with one id, and §5.6 says an edited `#. source:` never
+* changes what ships, which a build-stopping collision would; this narrows
+* the wording of INTERNALS §2.6.7 to that intent.
+*/
+function indexEntries(set, codec, ignoreKeys) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const loaded of set.values()) {
+		if (loaded.catalog === null) continue;
+		const { catalog } = resolveDuplicates(loaded.catalog, codec);
+		const file = posix(loaded.path);
+		for (const entry of catalog.entries) {
+			if (entry.manualId !== null || entry.foreignContext !== null || entry.source === null) continue;
+			const key = entryKey(entry, catalog.layout, codec);
+			if (key === null || ignoreKeys !== void 0 && ignoreKeys.has(key)) continue;
+			const canonical = canonicalOf(entry.source, codec);
+			if (canonical === null || codec.label(canonical) !== key) continue;
+			let texts = byKey.get(key);
+			if (texts === void 0) byKey.set(key, texts = /* @__PURE__ */ new Map());
+			const known = texts.get(canonical);
+			if (known === void 0) texts.set(canonical, {
+				locale: loaded.locale,
+				file,
+				line: entry.line,
+				translated: isTranslated(entry)
+			});
+			else if (!known.translated && isTranslated(entry)) known.translated = true;
+		}
+	}
+	return byKey;
+}
+function isTranslated(entry) {
+	return entry.translation !== "" && entry.state !== "untranslated";
+}
+function fixes(a, aTranslated, b, bTranslated, codec) {
+	const longer = `use a longer ids.length (now ${codec.idLength})`;
+	if (aTranslated !== bTranslated) return `give ${JSON.stringify(aTranslated ? b : a)} a manual id (it has no translations yet), or ${longer}`;
+	return `give the message that has no translations yet a manual id, or ${longer}`;
+}
+/**
+* `id-collision` errors for: two messages with one id and different
+* canonical text; a generated message and an entry of any locale with its id
+* but a different canonical source; two generated entries of the set with
+* one key and different sources.
+*
+* `referenced`: ids that count as live beyond `messages` (`extraction.keep`,
+* apps sharing the set that this scan does not cover). A colliding entry
+* whose text no message uses and whose id is not in `referenced` gets the
+* "run vi18n extract first" hint, since extract would delete it.
+* `ignoreKeys`: entries extract is about to delete, which therefore never
+* collide.
+*/
+function findCollisions(messages, set, codec, options = {}) {
+	const diagnostics = [];
+	const reported = /* @__PURE__ */ new Set();
+	const report = (id, a, b) => {
+		const pair = a < b ? `${id}\0${a}\0${b}` : `${id}\0${b}\0${a}`;
+		if (reported.has(pair)) return false;
+		reported.add(pair);
+		return true;
+	};
+	const entries = indexEntries(set, codec, options.ignoreKeys);
+	const byId = /* @__PURE__ */ new Map();
+	const literals = [];
+	for (const message of messages) {
+		if (!message.manual) for (const literal of message.sources ?? (message.source === void 0 ? [] : [message.source])) literals.push([message, literal]);
+		const first = byId.get(message.id);
+		if (first === void 0) byId.set(message.id, message);
+		else if (first.canonical !== message.canonical && report(message.id, first.canonical, message.canonical)) {
+			const a = messagePlace(first);
+			const b = messagePlace(message);
+			const texts = entries.get(message.id);
+			const fix = message.manual ? "give each text its own manual id" : fixes(first.canonical, texts?.get(first.canonical)?.translated === true, message.canonical, texts?.get(message.canonical)?.translated === true, codec);
+			const diagnostic = {
+				code: "id-collision",
+				severity: "error",
+				message: `${message.id} is the id of two texts, ${JSON.stringify(first.canonical)}${a.text} and ${JSON.stringify(message.canonical)}${b.text}: ${fix}`,
+				id: message.id,
+				related: [{
+					...b.file === void 0 ? {} : {
+						file: b.file,
+						line: b.line
+					},
+					message: message.canonical
+				}]
+			};
+			if (a.file !== void 0) {
+				diagnostic.file = a.file;
+				diagnostic.line = a.line;
+			}
+			diagnostics.push(diagnostic);
+		}
+	}
+	for (const [owner, literal] of literals) {
+		const other = byId.get(literal);
+		if (other === void 0 || other.id === owner.id) continue;
+		if (!report(literal, `\0source:${owner.id}`, other.canonical)) continue;
+		const a = messagePlace(owner);
+		const b = messagePlace(other);
+		const diagnostic = {
+			code: "id-collision",
+			severity: "error",
+			message: `${JSON.stringify(literal)} is the text of ${owner.id}${a.text} and the id of ${JSON.stringify(other.canonical)}${b.text}, so the server would render one for the other: ${other.manual ? "rename the manual id" : `give ${JSON.stringify(owner.canonical)} a manual id`}`,
+			id: literal,
+			related: [{
+				...b.file === void 0 ? {} : {
+					file: b.file,
+					line: b.line
+				},
+				message: other.canonical
+			}]
+		};
+		if (a.file !== void 0) {
+			diagnostic.file = a.file;
+			diagnostic.line = a.line;
+		}
+		diagnostics.push(diagnostic);
+	}
+	for (const message of byId.values()) {
+		if (message.manual) continue;
+		const texts = entries.get(message.id);
+		if (texts === void 0) continue;
+		const own = texts.get(message.canonical);
+		for (const [canonical, entry] of texts) {
+			if (canonical === message.canonical || !report(message.id, message.canonical, canonical)) continue;
+			const place = messagePlace(message);
+			const live = options.referenced?.has(message.id) === true;
+			const diagnostic = {
+				code: "id-collision",
+				severity: "error",
+				message: `${message.id} is the id of ${JSON.stringify(message.canonical)}${place.text} and of ${JSON.stringify(canonical)} in the ${entry.locale} catalog (${where(entry.file, entry.line)}): ` + fixes(message.canonical, own?.translated === true, canonical, entry.translated, codec) + (live ? "" : DELETED_HINT),
+				id: message.id,
+				locale: entry.locale,
+				related: [{
+					file: entry.file,
+					line: entry.line,
+					message: canonical
+				}]
+			};
+			if (place.file !== void 0) {
+				diagnostic.file = place.file;
+				diagnostic.line = place.line;
+			}
+			diagnostics.push(diagnostic);
+		}
+	}
+	const keys = [...entries.keys()].filter((key) => !byId.has(key) && entries.get(key).size > 1);
+	keys.sort();
+	for (const key of keys) {
+		const texts = [...entries.get(key)];
+		const [firstText, firstEntry] = texts[0];
+		const live = options.referenced?.has(key) === true;
+		for (const [canonical, entry] of texts.slice(1)) {
+			if (!report(key, firstText, canonical)) continue;
+			diagnostics.push({
+				code: "id-collision",
+				severity: "error",
+				message: `${key} is the id of ${JSON.stringify(firstText)} in the ${firstEntry.locale} catalog (${where(firstEntry.file, firstEntry.line)}) and of ${JSON.stringify(canonical)} in the ${entry.locale} catalog (${where(entry.file, entry.line)}): ` + fixes(firstText, firstEntry.translated, canonical, entry.translated, codec) + (live ? "" : DELETED_HINT),
+				id: key,
+				locale: firstEntry.locale,
+				file: firstEntry.file,
+				line: firstEntry.line,
+				related: [{
+					file: entry.file,
+					line: entry.line,
+					message: canonical
+				}]
+			});
+		}
+	}
+	return diagnostics;
+}
+//#endregion
+export { findCollisions as t };