@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/formats-KPIg-08V.js

@@ -0,0 +1,781 @@
+import { _ as parseJsonCatalog, g as serializePo, h as parsePo, v as serializeJsonCatalog, y as createEntry } from "./library-D5CWvTQs.js";
+import { t as VERSION } from "./version-BlyLGlOa.js";
+import { a as exchangeKey, s as parseExchangeKey } from "./units-CQ5Q99RC.js";
+//#region src/core/exchange/csv.ts
+/**
+* RFC 4180 CSV for `vi18n export --format csv` (PLAN §4.4 P2). The writer
+* starts with a UTF-8 byte order mark and ends rows with CRLF, which is what
+* spreadsheet apps need to open non-ASCII text correctly; the reader takes
+* either line ending, with or without the mark.
+*/
+const NEEDS_QUOTES = /[",\r\n]|^\s|\s$/;
+const FORMULA = /^'*[=+\-@\t\r]/;
+const GUARDED = /^'+[=+\-@\t\r]/;
+function field(raw) {
+	const value = FORMULA.test(raw) ? `'${raw}` : raw;
+	return NEEDS_QUOTES.test(value) ? `"${value.replaceAll("\"", "\"\"")}"` : value;
+}
+function unguard(cell) {
+	return GUARDED.test(cell) ? cell.slice(1) : cell;
+}
+function serializeCsv(rows) {
+	return `\uFEFF${rows.map((row) => row.map(field).join(",")).join("\r\n")}\r\n`;
+}
+var CsvError = class extends Error {
+	line;
+	constructor(message, line) {
+		super(message);
+		this.line = line;
+	}
+};
+/** Rows with the 1-based line each starts on; a quoted field may span lines. */
+function parseCsv(input) {
+	const text = input.charCodeAt(0) === 65279 ? input.slice(1) : input;
+	const rows = [];
+	let cells = [];
+	let cell = "";
+	let line = 1;
+	let rowLine = 1;
+	let i = 0;
+	let quoted = false;
+	let started = false;
+	const endRow = () => {
+		cells.push(unguard(cell));
+		if (!(cells.length === 1 && cells[0] === "")) rows.push({
+			cells,
+			line: rowLine
+		});
+		cells = [];
+		cell = "";
+		started = false;
+	};
+	while (i < text.length) {
+		const ch = text[i];
+		if (quoted) {
+			if (ch === "\"") {
+				if (text[i + 1] === "\"") {
+					cell += "\"";
+					i += 2;
+					continue;
+				}
+				quoted = false;
+				i++;
+				const next = text[i];
+				if (next !== void 0 && next !== "," && next !== "\n" && next !== "\r") throw new CsvError("text after a closing quote; double a quote inside a quoted field", line);
+				continue;
+			}
+			if (ch === "\n") line++;
+			cell += ch;
+			i++;
+			continue;
+		}
+		if (!started) {
+			rowLine = line;
+			started = true;
+		}
+		if (ch === "\"" && cell === "") {
+			quoted = true;
+			i++;
+		} else if (ch === ",") {
+			cells.push(unguard(cell));
+			cell = "";
+			i++;
+		} else if (ch === "\r" || ch === "\n") {
+			endRow();
+			i += ch === "\r" && text[i + 1] === "\n" ? 2 : 1;
+			line++;
+		} else {
+			cell += ch;
+			i++;
+		}
+	}
+	if (quoted) throw new CsvError("a quoted field is never closed", line);
+	if (started || cell !== "" || cells.length > 0) endRow();
+	return rows;
+}
+//#endregion
+//#region src/core/exchange/xml.ts
+var XmlError = class extends Error {
+	line;
+	constructor(message, line) {
+		super(message);
+		this.line = line;
+	}
+};
+const XML_NS = "http://www.w3.org/XML/1998/namespace";
+const NAME = /[A-Za-z_:\u00C0-\uFFFF][\w.:\u00B7\u00C0-\uFFFF-]*/y;
+const MAX_DEPTH = 256;
+const PREDEFINED = {
+	lt: "<",
+	gt: ">",
+	amp: "&",
+	quot: "\"",
+	apos: "'"
+};
+/** Characters XML 1.0 allows in a document (§2.2), surrogate pairs checked as pairs. */
+function isXmlChar(code) {
+	return code === 9 || code === 10 || code === 13 || code >= 32 && code <= 55295 || code >= 57344 && code <= 65533 || code >= 65536 && code <= 1114111;
+}
+/** Text content: `&`, `<` and `>` (the last so `]]>` can never appear). */
+function escapeText(value) {
+	return value.replace(/[&<>]/g, (ch) => ch === "&" ? "&amp;" : ch === "<" ? "&lt;" : "&gt;");
+}
+/** Attribute values in double quotes; whitespace as references, since readers normalise it to spaces. */
+function escapeAttribute(value) {
+	return value.replace(/[&<>"\t\n\r]/g, (ch) => {
+		switch (ch) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			default: return `&#${ch.charCodeAt(0)};`;
+		}
+	});
+}
+function parseXml(input) {
+	const text = (input.charCodeAt(0) === 65279 ? input.slice(1) : input).replace(/\r\n?/g, "\n");
+	let i = 0;
+	let line = 1;
+	const fail = (message) => {
+		throw new XmlError(message, line);
+	};
+	const advance = (to) => {
+		for (let k = i; k < to; k++) if (text.charCodeAt(k) === 10) line++;
+		i = to;
+	};
+	const expect = (literal) => {
+		if (!text.startsWith(literal, i)) fail(`expected ${JSON.stringify(literal)}`);
+		advance(i + literal.length);
+	};
+	const skipSpace = () => {
+		let k = i;
+		while (k < text.length && /[ \t\n]/.test(text[k])) k++;
+		advance(k);
+	};
+	const readName = () => {
+		NAME.lastIndex = i;
+		const match = NAME.exec(text);
+		if (match === null) return fail("expected a name");
+		advance(i + match[0].length);
+		return match[0];
+	};
+	const checkChars = (value) => {
+		for (const ch of value) if (!isXmlChar(ch.codePointAt(0))) fail("a character XML does not allow");
+	};
+	const decode = (raw) => {
+		checkChars(raw);
+		if (!raw.includes("&")) return raw;
+		return raw.replace(/&([^;&\s]*);?/g, (match, name) => {
+			if (!match.endsWith(";")) return fail("an unterminated entity reference");
+			if (name.startsWith("#")) {
+				const code = /^#x[0-9a-fA-F]+$/.test(name) ? Number.parseInt(name.slice(2), 16) : /^#\d+$/.test(name) ? Number(name.slice(1)) : NaN;
+				if (!isXmlChar(code)) return fail(`an invalid character reference &${name};`);
+				return String.fromCodePoint(code);
+			}
+			const value = Object.hasOwn(PREDEFINED, name) ? PREDEFINED[name] : void 0;
+			if (value === void 0) return fail(`an undeclared entity &${name};`);
+			return value;
+		});
+	};
+	/** Comments, processing instructions and white space between markup. */
+	const skipMisc = () => {
+		for (;;) {
+			skipSpace();
+			if (text.startsWith("<!--", i)) {
+				const end = text.indexOf("-->", i + 4);
+				if (end === -1) fail("an unterminated comment");
+				advance(end + 3);
+			} else if (text.startsWith("<?", i)) {
+				const end = text.indexOf("?>", i + 2);
+				if (end === -1) fail("an unterminated processing instruction");
+				advance(end + 2);
+			} else if (text.startsWith("<!DOCTYPE", i)) fail("a DOCTYPE; XLIFF needs none, and vi18n does not read entity declarations");
+			else return;
+		}
+	};
+	const resolve = (name, scopes, attribute) => {
+		const colon = name.indexOf(":");
+		const prefix = colon === -1 ? "" : name.slice(0, colon);
+		const local = colon === -1 ? name : name.slice(colon + 1);
+		if (prefix === "" && attribute) return {
+			ns: null,
+			local
+		};
+		if (prefix === "xml") return {
+			ns: XML_NS,
+			local
+		};
+		for (let s = scopes.length - 1; s >= 0; s--) {
+			const uri = scopes[s].get(prefix);
+			if (uri !== void 0) return {
+				ns: uri === "" ? null : uri,
+				local
+			};
+		}
+		if (prefix !== "") fail(`an undeclared namespace prefix ${prefix}:`);
+		return {
+			ns: null,
+			local
+		};
+	};
+	const element = (scopes, depth) => {
+		if (depth > MAX_DEPTH) fail(`elements nested more than ${MAX_DEPTH} deep`);
+		const start = line;
+		expect("<");
+		const name = readName();
+		const attrs = /* @__PURE__ */ new Map();
+		for (;;) {
+			const before = i;
+			skipSpace();
+			if (text.startsWith("/>", i) || text.startsWith(">", i)) break;
+			if (i === before) fail("expected white space between attributes");
+			const attr = readName();
+			skipSpace();
+			expect("=");
+			skipSpace();
+			const quote = text[i];
+			if (quote !== "\"" && quote !== "'") fail("expected a quoted attribute value");
+			const end = text.indexOf(quote, i + 1);
+			if (end === -1) fail("an unterminated attribute value");
+			const raw = text.slice(i + 1, end);
+			if (raw.includes("<")) fail("< in an attribute value");
+			advance(end + 1);
+			if (attrs.has(attr)) fail(`attribute ${attr} given twice`);
+			attrs.set(attr, decode(raw.replace(/[\t\n]/g, " ")));
+		}
+		const declared = /* @__PURE__ */ new Map();
+		for (const [attr, value] of attrs) if (attr === "xmlns") declared.set("", value);
+		else if (attr.startsWith("xmlns:")) declared.set(attr.slice(6), value);
+		const inner = declared.size > 0 ? [...scopes, declared] : scopes;
+		const { ns, local } = resolve(name, inner, false);
+		for (const attr of attrs.keys()) if (attr !== "xmlns" && !attr.startsWith("xmlns:")) resolve(attr, inner, true);
+		const node = {
+			kind: "element",
+			name,
+			ns,
+			local,
+			attrs,
+			children: [],
+			line: start
+		};
+		if (text.startsWith("/>", i)) {
+			advance(i + 2);
+			return node;
+		}
+		advance(i + 1);
+		let buffer = "";
+		const flush = () => {
+			if (buffer !== "") node.children.push({
+				kind: "text",
+				text: buffer
+			});
+			buffer = "";
+		};
+		for (;;) {
+			if (i >= text.length) fail(`<${name}> is never closed`);
+			if (text.startsWith("</", i)) {
+				flush();
+				advance(i + 2);
+				const end = readName();
+				if (end !== name) fail(`</${end}> closes <${name}>`);
+				skipSpace();
+				expect(">");
+				return node;
+			}
+			if (text.startsWith("<!--", i)) {
+				const end = text.indexOf("-->", i + 4);
+				if (end === -1) fail("an unterminated comment");
+				advance(end + 3);
+			} else if (text.startsWith("<![CDATA[", i)) {
+				const end = text.indexOf("]]>", i + 9);
+				if (end === -1) fail("an unterminated CDATA section");
+				const raw = text.slice(i + 9, end);
+				checkChars(raw);
+				buffer += raw;
+				advance(end + 3);
+			} else if (text.startsWith("<?", i)) {
+				const end = text.indexOf("?>", i + 2);
+				if (end === -1) fail("an unterminated processing instruction");
+				advance(end + 2);
+			} else if (text[i] === "<") {
+				flush();
+				node.children.push(element(inner, depth + 1));
+			} else {
+				let end = text.indexOf("<", i);
+				if (end === -1) end = text.length;
+				const raw = text.slice(i, end);
+				if (raw.includes("]]>")) fail("]]> in text");
+				buffer += decode(raw);
+				advance(end);
+			}
+		}
+	};
+	skipMisc();
+	if (text[i] !== "<") fail("expected the root element");
+	const root = element([/* @__PURE__ */ new Map([["", ""]])], 0);
+	skipMisc();
+	if (i < text.length) fail("content after the root element");
+	return root;
+}
+/** Child elements of one namespace, in order. */
+function childElements(node, ns, local) {
+	const out = [];
+	for (const child of node.children) if (child.kind === "element" && child.ns === ns && (local === void 0 || child.local === local)) out.push(child);
+	return out;
+}
+//#endregion
+//#region src/core/exchange/xliff.ts
+const XLIFF_NS = "urn:oasis:names:tc:xliff:document:2.0";
+const AI_SUBSTATE = "vi18n:ai";
+const STATES = [
+	"initial",
+	"translated",
+	"reviewed",
+	"final"
+];
+/**
+* Segment content: characters XML cannot hold become `<cp hex>` (XLIFF 2
+* §4.3.1.8), and a carriage return a character reference, since readers
+* turn a literal one into a line feed.
+*/
+function content(value) {
+	let out = "";
+	for (const ch of escapeText(value)) {
+		const code = ch.codePointAt(0);
+		if (code === 13) out += "&#13;";
+		else if (isXmlChar(code)) out += ch;
+		else out += `<cp hex="${code.toString(16).toUpperCase().padStart(4, "0")}"/>`;
+	}
+	return out;
+}
+/** Notes hold text only; a character XML cannot hold is replaced. */
+function noteText(value) {
+	let out = "";
+	for (const ch of escapeText(value)) {
+		const code = ch.codePointAt(0);
+		out += code === 13 ? "&#13;" : isXmlChar(code) ? ch : "�";
+	}
+	return out;
+}
+/** White space a reader may normalise unless told to preserve it. */
+function space(value) {
+	return /[\t\n\r]|^ | $| {2}/.test(value) ? " xml:space=\"preserve\"" : "";
+}
+function serializeXliff(units, meta) {
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>"];
+	const target = meta.isSourceLocale ? "" : ` trgLang="${escapeAttribute(meta.locale)}"`;
+	lines.push(`<xliff xmlns="${XLIFF_NS}" version="2.0" srcLang="${escapeAttribute(meta.sourceLocale)}"${target}>`, "  <file id=\"vi18n\" canResegment=\"no\">");
+	for (const unit of units) {
+		lines.push(`    <unit id="${escapeAttribute(unit.id)}">`);
+		const notes = [];
+		for (const context of unit.entry.contexts) notes.push(`<note category="description">${noteText(context)}</note>`);
+		for (const comment of unit.entry.comments) notes.push(`<note category="comment">${noteText(comment)}</note>`);
+		for (const ref of unit.entry.refs) notes.push(`<note category="location">${noteText(ref)}</note>`);
+		if (unit.entry.maxLength !== null) notes.push(`<note category="max-length">${unit.entry.maxLength}</note>`);
+		if (notes.length > 0) {
+			lines.push("      <notes>");
+			for (const note of notes) lines.push(`        ${note}`);
+			lines.push("      </notes>");
+		}
+		const hasTarget = !meta.isSourceLocale && unit.translation !== "";
+		let state = "";
+		if (hasTarget) state = unit.fuzzy ? " state=\"initial\"" : unit.state === "ai" ? ` state="translated" subState="${AI_SUBSTATE}"` : " state=\"translated\"";
+		lines.push(`      <segment${state}>`);
+		lines.push(`        <source${space(unit.source)}>${content(unit.source)}</source>`);
+		if (hasTarget) lines.push(`        <target${space(unit.translation)}>${content(unit.translation)}</target>`);
+		lines.push("      </segment>", "    </unit>");
+	}
+	lines.push("  </file>", "</xliff>");
+	return `${lines.join("\n")}\n`;
+}
+/** Inline content as text; markup vi18n never writes (placeholders, codes) cannot be read back. */
+function inlineText(node) {
+	let text = "";
+	for (const child of node.children) {
+		if (child.kind === "text") {
+			text += child.text;
+			continue;
+		}
+		if (child.ns === "urn:oasis:names:tc:xliff:document:2.0" && child.local === "cp") {
+			const hex = child.attrs.get("hex") ?? "";
+			const code = /^[0-9a-fA-F]{1,6}$/.test(hex) ? Number.parseInt(hex, 16) : NaN;
+			if (!(code <= 1114111)) return { unsupported: `<cp hex="${hex}"/>` };
+			text += String.fromCodePoint(code);
+			continue;
+		}
+		if (child.ns === "urn:oasis:names:tc:xliff:document:2.0" && (child.local === "mrk" || child.local === "pc")) {
+			const inner = inlineText(child);
+			if ("unsupported" in inner) return inner;
+			text += inner.text;
+			continue;
+		}
+		if (child.ns === "urn:oasis:names:tc:xliff:document:2.0" && (child.local === "sm" || child.local === "em")) continue;
+		return { unsupported: `<${child.name}>` };
+	}
+	return { text };
+}
+function rank(state) {
+	return STATES.indexOf(state);
+}
+/**
+* Units of an XLIFF 2.x document, from every `<file>` and `<group>`. A unit's
+* segments and ignorables are joined back into one message; its state is
+* the least advanced of its segments'. A segment without `state` but with a
+* `<target>` counts as translated, since some tools never set one.
+*/
+function parseXliff(text) {
+	let root;
+	try {
+		root = parseXml(text);
+	} catch (error) {
+		if (!(error instanceof XmlError)) throw error;
+		return {
+			locale: null,
+			srcLang: null,
+			records: [],
+			error: {
+				message: `not well-formed XML: ${error.message}`,
+				line: error.line
+			}
+		};
+	}
+	const version = root.attrs.get("version") ?? "";
+	if (root.ns !== "urn:oasis:names:tc:xliff:document:2.0" || root.local !== "xliff" || !version.startsWith("2.")) return {
+		locale: null,
+		srcLang: null,
+		records: [],
+		error: {
+			message: root.local === "xliff" ? `XLIFF ${version || "without a version"} is not supported; export and import XLIFF 2.0` : `the root element is <${root.name}>, not an XLIFF 2 <xliff>`,
+			line: root.line
+		}
+	};
+	const records = [];
+	const walk = (node) => {
+		for (const child of node.children) {
+			if (child.kind !== "element" || child.ns !== "urn:oasis:names:tc:xliff:document:2.0") continue;
+			if (child.local === "group") walk(child);
+			else if (child.local === "unit") records.push(unitRecord(child));
+		}
+	};
+	for (const file of childElements(root, XLIFF_NS, "file")) walk(file);
+	return {
+		locale: root.attrs.get("trgLang") ?? null,
+		srcLang: root.attrs.get("srcLang") ?? null,
+		records,
+		error: null
+	};
+}
+function unitRecord(unit) {
+	const raw = unit.attrs.get("id") ?? "";
+	const { key, label } = parseExchangeKey(raw);
+	const record = {
+		line: unit.line,
+		ref: raw,
+		key: key === "" ? null : key,
+		label,
+		source: "",
+		translation: "",
+		state: "translated",
+		draft: false
+	};
+	let source = "";
+	let target = "";
+	let complete = true;
+	let least = "final";
+	let ai = false;
+	for (const part of unit.children) {
+		if (part.kind !== "element" || part.ns !== "urn:oasis:names:tc:xliff:document:2.0") continue;
+		if (part.local !== "segment" && part.local !== "ignorable") continue;
+		const [from] = childElements(part, XLIFF_NS, "source");
+		const [to] = childElements(part, XLIFF_NS, "target");
+		const sourceText = from === void 0 ? { text: "" } : inlineText(from);
+		const targetText = to === void 0 ? null : inlineText(to);
+		if ("unsupported" in sourceText) return {
+			...record,
+			unsupported: sourceText.unsupported
+		};
+		if (targetText !== null && "unsupported" in targetText) return {
+			...record,
+			unsupported: targetText.unsupported
+		};
+		source += sourceText.text;
+		if (part.local === "ignorable") {
+			target += targetText === null ? sourceText.text : targetText.text;
+			continue;
+		}
+		if (targetText === null) complete = false;
+		else target += targetText.text;
+		const written = part.attrs.get("state");
+		const state = STATES.includes(written ?? "") ? written : targetText === null ? "initial" : "translated";
+		if (rank(state) < rank(least)) least = state;
+		if (state === "translated" && part.attrs.get("subState") === "vi18n:ai") ai = true;
+	}
+	record.source = source;
+	if (!complete) return record;
+	record.translation = target;
+	record.draft = least === "initial";
+	record.state = least === "translated" && ai ? "ai" : "translated";
+	return record;
+}
+//#endregion
+//#region src/core/exchange/formats.ts
+/**
+* Export writers and import readers per format (PLAN §4.4, §5.19). Bilingual
+* formats (PO, vi18n JSON, XLIFF 2, CSV) carry each unit's source; key-only
+* formats (flat JSON, ARB) carry a value per key, which is the source text in
+* the source locale's file and the translation in a target's, the usual pair
+* a key-value TMS uploads. A key-only target file holds only translations
+* that would ship and `""` for the rest, so re-importing it can never turn a
+* fuzzy or invalid draft into a translation.
+*/
+/** CSV columns, in the order written; import finds them by name. */
+const CSV_COLUMNS = [
+	"key",
+	"source",
+	"translation",
+	"state",
+	"context"
+];
+function serializeExport(format, units, meta) {
+	switch (format) {
+		case "po":
+		case "json": return catalogText(format, units, meta);
+		case "xliff2": return serializeXliff(units, meta);
+		case "flat": {
+			const members = units.map((unit) => `  ${JSON.stringify(exchangeKey(unit))}: ${JSON.stringify(keyOnlyValue(unit, meta))}`);
+			return members.length === 0 ? "{}\n" : `{\n${members.join(",\n")}\n}\n`;
+		}
+		case "arb": {
+			const members = [`  "@@locale": ${JSON.stringify(meta.locale)}`];
+			for (const unit of units) {
+				const key = exchangeKey(unit);
+				members.push(`  ${JSON.stringify(key)}: ${JSON.stringify(keyOnlyValue(unit, meta))}`);
+				if (unit.entry.contexts.length > 0) {
+					const description = JSON.stringify(unit.entry.contexts.join("\n"));
+					members.push(`  ${JSON.stringify(`@${key}`)}: { "description": ${description} }`);
+				}
+			}
+			return `{\n${members.join(",\n")}\n}\n`;
+		}
+		case "csv": {
+			const rows = [[...CSV_COLUMNS]];
+			for (const unit of units) {
+				const state = meta.isSourceLocale ? "" : unit.fuzzy ? "fuzzy" : unit.state;
+				rows.push([
+					exchangeKey(unit),
+					unit.source,
+					meta.isSourceLocale ? "" : unit.translation,
+					state,
+					unit.entry.contexts.join("\n")
+				]);
+			}
+			return serializeCsv(rows);
+		}
+	}
+}
+function keyOnlyValue(unit, meta) {
+	if (meta.isSourceLocale) return unit.source;
+	return unit.usable ? unit.translation : "";
+}
+/** A PO or vi18n JSON catalog holding just the exported units, written by the catalog writers. */
+function catalogText(format, units, meta) {
+	const layout = format === "json" ? "json" : meta.msgid;
+	const sameFormat = format === "json" === (meta.layout === "json");
+	const catalog = {
+		locale: meta.locale,
+		layout,
+		header: {
+			language: meta.locale,
+			idScheme: meta.idScheme,
+			sourceLocale: meta.sourceLocale,
+			aiModel: meta.header?.aiModel ?? null,
+			extra: sameFormat ? meta.header?.extra ?? [] : []
+		},
+		entries: units.map((unit) => createEntry({
+			...unit.entry,
+			manualId: unit.manual ? unit.id : null,
+			foreignContext: null,
+			label: layout === "id" ? unit.label : layout === "json" && !unit.manual ? unit.id : null,
+			source: unit.source,
+			translation: unit.translation,
+			state: unit.state,
+			fuzzy: unit.fuzzy,
+			line: 0,
+			wrapped: false
+		})),
+		obsolete: [],
+		droppedObsolete: 0
+	};
+	const options = {
+		isSourceLocale: meta.isSourceLocale,
+		version: VERSION
+	};
+	return format === "json" ? serializeJsonCatalog(catalog, options) : serializePo(catalog, options);
+}
+/** Reads an import file; `msgid` is the PO layout to read it in (the project's `catalogs.msgid`). */
+function readImport(format, text, options) {
+	switch (format) {
+		case "po": return readPo(text, options.msgid);
+		case "json": return readJson(text);
+		case "xliff2": return parseXliff(text);
+		case "flat": return readKeyValue(text, false);
+		case "arb": return readKeyValue(text, true);
+		case "csv": return readCsv(text);
+	}
+}
+function failed(message, line = 0) {
+	return {
+		locale: null,
+		records: [],
+		error: {
+			message,
+			line
+		}
+	};
+}
+function readPo(text, layout) {
+	const { catalog, diagnostics } = parsePo(text, {
+		locale: "",
+		layout,
+		isSourceLocale: false
+	});
+	const error = diagnostics.find((diagnostic) => diagnostic.severity === "error");
+	if (error !== void 0) return failed(error.message, error.line ?? 0);
+	const records = catalog.entries.map((entry) => ({
+		line: entry.line,
+		ref: entry.manualId ?? entry.foreignContext ?? (layout === "id" ? entry.label : entry.source) ?? "",
+		key: entry.foreignContext !== null ? `\u0004${entry.foreignContext}` : entry.manualId ?? (layout === "id" ? entry.label : null),
+		label: layout === "id" ? entry.label : null,
+		source: layout === "id" ? null : entry.source,
+		translation: entry.translation,
+		state: entry.state === "ai" ? "ai" : "translated",
+		draft: entry.fuzzy
+	}));
+	return {
+		locale: catalog.header.language === "" ? null : catalog.header.language,
+		records,
+		error: null
+	};
+}
+function readJson(text) {
+	const { catalog, diagnostics } = parseJsonCatalog(text, {
+		locale: "",
+		isSourceLocale: false
+	});
+	const error = diagnostics.find((diagnostic) => diagnostic.severity === "error");
+	if (error !== void 0) return failed(error.message, error.line ?? 0);
+	const records = catalog.entries.map((entry) => ({
+		line: entry.line,
+		ref: entry.manualId ?? entry.label ?? "",
+		key: entry.manualId ?? entry.label,
+		label: null,
+		source: entry.source,
+		translation: entry.translation,
+		state: entry.state === "ai" ? "ai" : "translated",
+		draft: entry.fuzzy
+	}));
+	return {
+		locale: catalog.header.language === "" ? null : catalog.header.language,
+		records,
+		error: null
+	};
+}
+/** 1-based line of each top-level member, found by a light scan (JSON.parse gives none). */
+function memberLines(text) {
+	const lines = /* @__PURE__ */ new Map();
+	for (const match of text.matchAll(/^[ \t]*("(?:[^"\\\n]|\\.)*")\s*:/gm)) try {
+		const key = JSON.parse(match[1]);
+		if (!lines.has(key)) lines.set(key, text.slice(0, match.index).split("\n").length);
+	} catch {}
+	return lines;
+}
+/**
+* Flat JSON and ARB: string values by key. Nested objects (a TMS's "nested
+* JSON" splits keys at dots) are joined back with `.`; ARB's `@@…` and
+* `@key` metadata members are not messages.
+*/
+function readKeyValue(text, arb) {
+	let root;
+	try {
+		root = JSON.parse(text.charCodeAt(0) === 65279 ? text.slice(1) : text);
+	} catch (error) {
+		return failed(error instanceof Error ? error.message : String(error));
+	}
+	if (typeof root !== "object" || root === null || Array.isArray(root)) return failed("expected a JSON object of keys and strings");
+	const lines = memberLines(text);
+	const records = [];
+	let locale = null;
+	let bad = null;
+	const walk = (value, prefix, top) => {
+		for (const [name, inner] of Object.entries(value)) {
+			if (arb && top && name.startsWith("@")) {
+				if (name === "@@locale" && typeof inner === "string") locale = inner;
+				continue;
+			}
+			const path = prefix === "" ? name : `${prefix}.${name}`;
+			if (typeof inner === "string") {
+				const { key, label } = parseExchangeKey(path);
+				records.push({
+					line: lines.get(name) ?? 0,
+					ref: path,
+					key,
+					label,
+					source: null,
+					translation: inner,
+					state: null,
+					draft: false
+				});
+			} else if (!arb && typeof inner === "object" && inner !== null && !Array.isArray(inner)) walk(inner, path, false);
+			else bad ??= path;
+		}
+	};
+	walk(root, "", true);
+	if (bad !== null) return failed(`${JSON.stringify(bad)} is not a string`, lines.get(bad) ?? 0);
+	return {
+		locale,
+		records,
+		error: null
+	};
+}
+function readCsv(text) {
+	let rows;
+	try {
+		rows = parseCsv(text);
+	} catch (error) {
+		if (error instanceof CsvError) return failed(error.message, error.line);
+		throw error;
+	}
+	const header = rows[0];
+	if (header === void 0) return failed("the file is empty; expected a header row");
+	const column = (name) => header.cells.findIndex((cell) => cell.trim() === name);
+	const keyAt = column("key");
+	const translationAt = column("translation");
+	if (keyAt === -1 || translationAt === -1) return failed("the header row needs \"key\" and \"translation\" columns", header.line);
+	const sourceAt = column("source");
+	const stateAt = column("state");
+	const records = [];
+	for (const row of rows.slice(1)) {
+		const raw = row.cells[keyAt] ?? "";
+		if (raw === "") continue;
+		const { key, label } = parseExchangeKey(raw);
+		const source = sourceAt === -1 ? "" : row.cells[sourceAt] ?? "";
+		const state = stateAt === -1 ? "" : (row.cells[stateAt] ?? "").trim();
+		records.push({
+			line: row.line,
+			ref: raw,
+			key,
+			label,
+			source: source === "" ? null : source,
+			translation: row.cells[translationAt] ?? "",
+			state: state === "ai" ? "ai" : stateAt === -1 ? null : "translated",
+			draft: state === "fuzzy"
+		});
+	}
+	return {
+		locale: null,
+		records,
+		error: null
+	};
+}
+//#endregion
+export { serializeExport as n, readImport as t };