prosebook 0.3.0 → 0.4.0

package/dist/{generate-9pR3i5Bj.js → generate-BW3N8EGb.js}

@@ -1,7 +1,7 @@
 import { n as chainOf } from "./locale-DpQA1pqH.js";
 import { a as formatsOf, c as parseMessage$1, d as staticLiteral, f as tagsOf, i as formatProblems, l as placeholderOf, n as argsOf, o as numberOptions, p as walk, s as optionArgsOf, t as TYPE$1, u as selectionOf } from "./icu-Dej0mNsF.js";
 import { d as localeModule, l as compileLocale } from "./scan-Bx0_yDSi.js";
-import { p as lint, u as applyEdits } from "./config-BPSmoYel.js";
+import { p as lint, u as applyEdits } from "./config-nWZf9QmF.js";
 import { dirname, join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { SKELETON_TYPE, TYPE, isDateElement, isNumberElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
@@ -33,7 +33,7 @@ const CATEGORY_ORDER = [
 function print$1(elements, inPlural) {
 	return elements.map((el, i) => {
 		switch (el.type) {
-			case TYPE.literal: return escape(el.value, inPlural, elements[i + 1] === void 0);
+			case TYPE.literal: return escape$2(el.value, inPlural, elements[i + 1] === void 0);
 			case TYPE.argument: return `{${el.value}}`;
 			case TYPE.number:
 			case TYPE.date:
@@ -66,7 +66,7 @@ function print$1(elements, inPlural) {
 * Literal text, quoted where ICU would read it as syntax. An apostrophe starts a quote only before a
 * special character, so one before ordinary text (`don't`) stays single.
 */
-function escape(text, inPlural, last) {
+function escape$2(text, inPlural, last) {
 	const special = (c) => c === "{" || c === "}" || c === "<" || inPlural && c === "#";
 	let out = "";
 	for (let i = 0; i < text.length; i++) {
@@ -2371,246 +2371,6 @@ function checkNames(language, named, taken) {
 		seen.set(name, key);
 	}
 }
-// src/tools/native/kotlin.ts
-const KEYWORDS$2 = new Set("as break class continue do else false for fun if in interface is null object package return super this throw true try typealias typeof val var when while".split(" "));
-const ident$2 = (name) => KEYWORDS$2.has(name) ? `\`${name}\`` : name;
-const lit$2 = (value) => stringLiteral(value, "kotlin");
-const entry = (tag) => leading(upper(wordsOf(tag)));
-const argName$2 = (name) => ident$2(leading(camel(wordsOf(name))));
-function doc$3(lines, indent) {
-	return `${indent}/**\n${lines.map((l) => l.replaceAll("*/", "*\\/")).map((l) => l === "" ? `${indent} *` : `${indent} * ${l}`).join("\n")}\n${indent} */\n`;
-}
-/** The parts as an expression of type `String`, with `rt` the runtime object. */
-function expr$2(parts, indent, rt) {
-	if (parts.length === 0) return "\"\"";
-	return parts.map((p) => p.type === "text" ? lit$2(p.value) : value$2(p, indent, rt)).join(" + ");
-}
-function value$2(part, indent, rt) {
-	const inner = `${indent}    `;
-	if (part.type === "string") return argName$2(part.arg);
-	if (part.type === "number") return `${rt}.number(${part.offset === 0 ? argName$2(part.arg) : `${argName$2(part.arg)} - ${float(part.offset)}`}, ${rt}.F${part.format}, ${lit$2(part.fallback)})`;
-	if (part.type === "select") {
-		const arms = part.arms.map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
-		return `when (${argName$2(part.arg)}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
-	}
-	if (part.arms.length + part.exact.length === 0) return expr$2(part.other, indent, rt);
-	const arg = argName$2(part.arg);
-	const on = part.on === "round" ? `${rt}.round(${arg})` : part.on === "percent" ? `${arg} * 100.0` : arg;
-	const { minFrac, maxFrac } = part.rounding;
-	const exact = part.exact.map((e) => `${float(e.value)} to ${lit$2(`=${e.value}`)}`).join(", ");
-	const arms = [...part.exact.map((e) => ({
-		key: `=${e.value}`,
-		parts: e.parts
-	})), ...part.arms].map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
-	return `when (${`${rt}.plural(${on}, ${float(part.offset)}, listOf(${exact}), ${rt}::r${part.rules}, ${minFrac}, ${maxFrac})`}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
-}
-function member$1(m, name, rt) {
-	const branches = m.bodies.map((b) => `            ${b.locales.map(entry).join(", ")} -> ${expr$2(b.parts, "            ", rt)}\n`).join("");
-	const argDocs = m.args.filter((a) => a.doc !== void 0).map((a) => `@param ${argName$2(a.name)} ${a.doc}`);
-	const head = doc$3(argDocs.length > 0 ? [
-		...m.doc,
-		"",
-		...argDocs
-	] : m.doc, "    ");
-	const body = `when (this) {\n${branches}        }`;
-	if (m.args.length === 0) return `${head}    val ${name}: String\n        get() = ${body}\n`;
-	return `${head}    fun ${name}(${m.args.map((a) => `${argName$2(a.name)}: ${a.type === "number" ? "Number" : "String"}`).join(", ")}): String {\n${m.args.filter((a) => a.type === "number").map((a) => `        val ${argName$2(a.name)} = ${argName$2(a.name)}.toDouble()\n`).join("")}        return ${body}\n    }\n`;
-}
-function formatConst$2(spec, i) {
-	const affix = ([prefix, suffix]) => `${lit$2(prefix)} to ${lit$2(suffix)}`;
-	return `    val F${i} = Format(\n${[
-		spec.minInt,
-		spec.minFrac,
-		spec.maxFrac,
-		spec.shift,
-		spec.grouping.primary,
-		spec.grouping.secondary,
-		spec.grouping.min,
-		lit$2(spec.decimal),
-		lit$2(spec.group),
-		spec.digits === void 0 ? "null" : `listOf(${spec.digits.map(lit$2).join(", ")})`,
-		affix(spec.positive),
-		affix(spec.negative),
-		affix(spec.zero),
-		affix(spec.negativeZero),
-		lit$2(spec.infinity),
-		lit$2(spec.negativeInfinity)
-	].map((f) => `        ${f}`).join(",\n")},\n    )\n`;
-}
-const NUMBER$2 = `
-    /** A number format, taken apart when the file was generated. */
-    class Format(
-        val minInt: Int,
-        val minFrac: Int,
-        val maxFrac: Int,
-        val shift: Int,
-        val primary: Int,
-        val secondary: Int,
-        val minGroup: Int,
-        val decimal: String,
-        val group: String,
-        val digits: List<String>?,
-        val positive: Pair<String, String>,
-        val negative: Pair<String, String>,
-        val zero: Pair<String, String>,
-        val negativeZero: Pair<String, String>,
-        val infinity: String,
-        val negativeInfinity: String,
-    )
-
-    /** \`value\` as \`format\` writes it, or \`fallback\` where it isn't a number. */
-    fun number(value: Double, format: Format, fallback: String): String {
-        if (value.isNaN()) return fallback
-        if (value.isInfinite()) return if (value > 0) format.infinity else format.negativeInfinity
-        val (written, frac) = digits(Math.abs(value), format.shift, format.minFrac, format.maxFrac)
-        val zero = (written + frac).all { it == '0' }
-        val negative = value.toRawBits() < 0
-        val (prefix, suffix) = if (zero) (if (negative) format.negativeZero else format.zero) else (if (negative) format.negative else format.positive)
-        val int = written.padStart(maxOf(format.minInt, 1), '0')
-        val grouped = format.minGroup > 0 && int.length >= format.primary + format.minGroup
-        val out = StringBuilder(prefix)
-        for ((i, digit) in int.withIndex()) {
-            val left = int.length - i
-            if (grouped && i > 0 && (left == format.primary || (left > format.primary && (left - format.primary) % format.secondary == 0))) {
-                out.append(format.group)
-            }
-            out.append(shown(digit, format))
-        }
-        if (frac.isNotEmpty()) {
-            out.append(format.decimal)
-            for (digit in frac) out.append(shown(digit, format))
-        }
-        return out.append(suffix).toString()
-    }
-
-    private fun shown(digit: Char, format: Format): String = format.digits?.get(digit - '0') ?: digit.toString()
-
-    /**
-     * The shortest digits that read back as \`value\`, as \`Intl\` rounds them: moved \`shift\` places
-     * right, rounded half away from zero to \`max\` fraction digits, and trailing zeros cut to \`min\`.
-     */
-    fun digits(value: Double, shift: Int, min: Int, max: Int): Pair<String, String> {
-        // \`toString\` writes the shortest digits that read back, with an exponent past a size.
-        val plain = java.math.BigDecimal(value.toString()).toPlainString()
-        val int = plain.substringBefore('.')
-        val all = (int + plain.substringAfter('.', "")).map { it - '0' }.toMutableList()
-        var point = int.length + shift
-        while (all.size <= point + max) all.add(0)
-        val next = all[point + max]
-        while (all.size > point + max) all.removeAt(all.size - 1)
-        if (next >= 5) {
-            var at = all.size - 1
-            while (at >= 0 && all[at] == 9) all[at--] = 0
-            if (at < 0) {
-                all.add(0, 1)
-                point += 1
-            } else {
-                all[at] += 1
-            }
-        }
-        val frac = all.subList(point, all.size).toMutableList()
-        while (frac.size > min && frac.last() == 0) frac.removeAt(frac.size - 1)
-        return all.subList(0, point).dropWhile { it == 0 }.joinToString("") to frac.joinToString("")
-    }
-`;
-const PLURAL$2 = `
-    /** CLDR's plural operands of a number as written. */
-    class Operands(val n: Double, val i: Double, val v: Double, val w: Double, val f: Double, val t: Double, val c: Double, val e: Double)
-
-    /** The arm a plural takes: the \`=N\` that \`value\` equals, else the category of \`value\` less \`offset\`. */
-    fun plural(value: Double, offset: Double, exact: List<Pair<Double, String>>, rules: (Operands) -> String, min: Int, max: Int): String =
-        exact.firstOrNull { it.first == value }?.second ?: category(rules, value - offset, min, max)
-
-    /** The category \`rules\` give \`value\`, rounded to between \`min\` and \`max\` fraction digits. */
-    private fun category(rules: (Operands) -> String, value: Double, min: Int, max: Int): String {
-        if (!value.isFinite()) return "other"
-        val (written, frac) = digits(Math.abs(value), 0, min, max)
-        val int = written.ifEmpty { "0" }
-        val trimmed = frac.trimEnd('0')
-        val read = { s: String -> s.toDoubleOrNull() ?: 0.0 }
-        return rules(
-            Operands(
-                n = read(if (frac.isEmpty()) int else "$int.$frac"),
-                i = read(int),
-                v = frac.length.toDouble(),
-                w = trimmed.length.toDouble(),
-                f = read(frac),
-                t = read(trimmed),
-                c = 0.0,
-                e = 0.0,
-            ),
-        )
-    }
-
-    /** An integer in the range, as CLDR's ranges hold. */
-    private fun within(value: Double, from: Double, to: Double): Boolean = value % 1.0 == 0.0 && value >= from && value <= to
-
-    /** \`Math.round\`: half up, toward positive infinity. */
-    fun round(value: Double): Double {
-        val floor = Math.floor(value)
-        return if (value - floor >= 0.5) floor + 1 else floor
-    }
-`;
-function kotlinFile(model, target, banner) {
-	const name = target.name;
-	const rt = `${name}Runtime`;
-	const names = model.messages.map((m) => [m.key, ident$2(leading(camel(m.words)))]);
-	checkNames("kotlin", names, [
-		"tag",
-		"name",
-		"ordinal",
-		"entries",
-		"negotiate",
-		"SOURCE"
-	]);
-	const entries = model.locales.map((l) => `    /** \`${l}\`${l === model.source ? ", the source" : ""}. */\n    ${entry(l)}(${lit$2(l)})`).join(",\n");
-	const members = model.messages.map((m, i) => member$1(m, names[i][1], rt)).join("\n");
-	const rules = model.rules.map(({ name: rule, rules }, i) => {
-		return `    /** ${rule} */\n    fun r${i}(o: Operands): String {\n${rules.map(([category, condition]) => `        if (${conditionCode(condition, {
-			field: (op) => `o.${op}`,
-			mod: (v, by) => `${v} % ${by}`,
-			within: (v, from, to) => `within(${v}, ${from}, ${to})`
-		})}) return ${lit$2(category)}\n`).join("")}        return "other"\n    }\n`;
-	}).join("\n");
-	const runtime = model.formats.length + model.rules.length === 0 ? "" : `
-/** What formats the messages, generated with them. */
-private object ${rt} {${NUMBER$2}${model.rules.length > 0 ? PLURAL$2 : ""}
-${model.formats.map(formatConst$2).join("\n")}${rules === "" ? "" : `\n${rules}`}}
-`;
-	return `${banner}
-@file:Suppress("unused", "NAME_SHADOWING", "KotlinConstantConditions", "ConvertTwoComparisonsToRangeCheck")
-${target.package === void 0 ? "" : `\npackage ${target.package}\n`}
-/** A locale the catalog is written or translated in, and its messages. */
-enum class ${name}(val tag: String) {
-${entries};
-
-${members}
-    companion object {
-        /** The locale the catalog is written in, which every message falls back to. */
-        val SOURCE: ${name} = ${entry(model.source)}
-
-        /**
-         * The best locale for what was asked, most preferred first: each tag tries an exact match, then
-         * its parents (\`pt-BR\` finds \`pt\`), then any locale of its language. The source if none is.
-         */
-        fun negotiate(requested: List<String>): ${name} {
-            fun language(tag: String) = tag.substringBefore('-').lowercase()
-            for (want in requested) {
-                var tag = want
-                while (true) {
-                    entries.firstOrNull { it.tag.equals(tag, ignoreCase = true) }?.let { return it }
-                    val cut = tag.lastIndexOf('-')
-                    if (cut < 0) break
-                    tag = tag.substring(0, cut)
-                }
-                entries.firstOrNull { language(it.tag) == language(want) }?.let { return it }
-            }
-            return SOURCE
-        }
-    }
-}
-${runtime}`;
-}
 // src/tools/native/number.ts
 const NUMBER_PARTS = /* @__PURE__ */ new Set([
 	"integer",
@@ -4015,10 +3775,22 @@ function parseRelation(source) {
 * tree per locale it renders in, with every fallback resolved here, so the generated code has no
 * lookup to do. Number formats and plural rules are read from `Intl` and CLDR once, and numbered.
 */
-/** Whether a target takes `key`, and the prefix that took it in (longest first), which its name leaves out. */
-function prefixOf(target, key) {
-	if (target.keys === void 0) return "";
-	return [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+/**
+* The words a target names `key` by, less the prefix that took it in (longest first): `tray.quit-app`
+* is quit, app under `['tray']`. Nothing when the target doesn't take the key.
+*/
+function wordsFor(target, key) {
+	return restOf(target, key)?.split(/[.\-_]/).filter(Boolean);
+}
+/** `key` less the prefix that took it in, as written: `tray.quit-app` is `quit-app` under `['tray']`. */
+function restOf(target, key) {
+	const prefix = target.keys === void 0 ? "" : [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+	if (prefix === void 0) return void 0;
+	return key.slice(prefix === "" ? 0 : prefix.length + 1);
+}
+/** The locale whose text `locale` shows for `key`: its own, else the first down its fallback chain that has it. */
+function foundIn(key, locale, locales, asts) {
+	return chainOf(locale, locales, locales[0]).find((l) => asts.get(l)?.has(key));
 }
 /** Values a file declares once each, numbered by what they hold, so locales that format alike share one. */
 var Numbered = class {
@@ -4042,13 +3814,12 @@ function nativeModel(target, catalog, locales, entries) {
 	const problems = [];
 	const messages = [];
 	for (const m of catalog.messages) {
-		const prefix = prefixOf(target, m.key);
-		if (prefix === void 0) continue;
-		const words = m.key.slice(prefix === "" ? 0 : prefix.length + 1).split(/[.\-_]/).filter(Boolean);
+		const words = wordsFor(target, m.key);
+		if (words === void 0) continue;
 		const bodies = /* @__PURE__ */ new Map();
 		let failed = false;
 		for (const locale of locales) {
-			const found = chainOf(locale, locales, source).find((l) => asts.get(l)?.has(m.key));
+			const found = foundIn(m.key, locale, locales, asts);
 			if (found === void 0) continue;
 			const body = bodies.get(found);
 			if (body !== void 0) {
@@ -4230,18 +4001,557 @@ function parts(elements, locale, formats, rules, pound) {
 	}
 	return out;
 }
-// src/tools/native/rust.ts
-const KEYWORDS$1 = new Set("as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while abstract become box do final macro override priv try typeof unsized virtual yield gen".split(" "));
-const ident$1 = (name) => KEYWORDS$1.has(name) ? `${name}_` : name;
-const lit$1 = (value) => stringLiteral(value, "rust");
-const variant = (tag) => pascal(wordsOf(tag));
-const argName$1 = (name) => ident$1(leading(snake(wordsOf(name))));
-function doc$2(lines, indent) {
-	return lines.map((l) => l === "" ? `${indent}///\n` : `${indent}/// ${l}\n`).join("");
-}
-/** The parts as an expression of type `String`. */
-function expr$1(parts, indent) {
-	if (parts.length === 0) return "String::new()";
+// src/tools/native/printf.ts
+/**
+* Messages as printf-style format strings, for the targets whose platform fills values in itself:
+* Android's resources and Apple's `.strings` files. Text and plain `{name}` placeholders, as `%N$s`
+* with N the argument's place in the message's arguments, so a translation can put them in another
+* order; anything `Intl` would format fails with the fix.
+*/
+/** The context and what each argument holds, on one line, for the comment above an entry. */
+function noteOf(m) {
+	return docText([m.context, ...[...m.args.keys()].map((a) => m.argDocs.has(a) ? `${a}: ${m.argDocs.get(a).replace(/\.$/, "")}.` : void 0)].filter((l) => l !== void 0 && l !== "").join(" "));
+}
+/** What a plural's arms may hold as its count: `#`, or the count as a plain `:number` or `:integer`. */
+function isCount(el, count) {
+	if (el.type === TYPE$1.pound) return true;
+	if (!isNumberElement(el) || el.value !== count) return false;
+	const options = Object.entries(numberOptions(el) ?? {});
+	return options.length === 0 || options.length === 1 && options[0][0] === "maximumFractionDigits" && options[0][1] === 0;
+}
+/** `elements` as a format string over `args`; inside a plural, its `count` is `%N$d`. */
+function formatString(elements, args, printf, count) {
+	const formatted = args.length > 0;
+	const place = (el, name, conversion) => {
+		const at = args.indexOf(name);
+		if (at < 0) throw new Error(`{${name}} is not an argument of this message: say it in the source text too`);
+		const { isolate } = placeholderOf(el, name);
+		const spec = `%${at + 1}$${conversion}`;
+		return isolate === void 0 ? spec : `${printf.escape(isolate[0], formatted)}${spec}${printf.escape(isolate[1], formatted)}`;
+	};
+	let out = "";
+	for (const el of elements) {
+		if (count !== void 0 && isCount(el, count)) {
+			out += place(el, count, "d");
+			continue;
+		}
+		if (isDateElement(el) || isTimeElement(el)) throw new Error(`{${el.value}} is a date, which ${printf.holder} don't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`);
+		if (isNumberElement(el)) throw new Error(`{${el.value}} is a formatted number, and ${printf.platform} fills values in with ${printf.formatter}, not Intl: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`);
+		switch (el.type) {
+			case TYPE$1.literal:
+				out += printf.escape(el.value, formatted);
+				break;
+			case TYPE$1.argument:
+				out += place(el, el.value, printf.string);
+				break;
+			case TYPE$1.pound:
+				out += "#";
+				break;
+			case TYPE$1.select: throw new Error(`{${el.value}} is a select, which ${printf.holder} can't hold: write a key per case and pick one in code, ${LEAVE_OUT}`);
+			case TYPE$1.plural: throw new Error(printf.plural(el.value));
+			case TYPE$1.tag: throw new Error(`<${el.value}> is a tag, and ${printf.holder} here hold plain text: say it without the tag, ${LEAVE_OUT}`);
+			default: throw new Error(`prosebook: no ${printf.platform} writer for ICU element type ${el.type}`);
+		}
+	}
+	return out;
+}
+// src/tools/native/android.ts
+/**
+* The catalog as Android string resources: `values/<name>.xml` for the source and
+* `values-<qualifier>/<name>.xml` for every other locale, each holding what that locale shows, every
+* fallback resolved. An app with the Kotlin target still needs these: its manifest, shortcuts and
+* other XML resources name strings as `@string/…`, which only a resource answers.
+*
+* Android fills values in with `String.format` and picks a plural's arm itself, from its own CLDR
+* rules, so this takes a narrower subset than the other targets, written straight from the ICU tree:
+* text, plain `{name}` placeholders, and one cardinal plural, with the text around it in each arm.
+*/
+const KEYWORDS$3 = new Set("abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while".split(" "));
+/**
+* A locale as Android's resource qualifier: `de`, `pt-rBR`, and BCP 47's own form, `b+sr+Latn`,
+* past what the old form holds (a script, a numeric region, a variant).
+*/
+function qualifierOf(locale) {
+	const [language = "", ...rest] = locale.split(/[-_]/);
+	const subtags = [language.toLowerCase(), ...rest.map((s) => s.length === 4 && /^[a-z]+$/i.test(s) ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : s.length === 2 ? s.toUpperCase() : s.toLowerCase())];
+	if (!(/^[a-z]{2,3}$/.test(subtags[0]) && (rest.length === 0 || rest.length === 1 && /^[A-Z]{2}$/.test(subtags[1])))) return `b+${subtags.join("+")}`;
+	return rest.length === 0 ? subtags[0] : `${subtags[0]}-r${subtags[1]}`;
+}
+/** Whitespace as aapt2 reads it: collapsed to one space, and trimmed at the ends, outside double quotes. */
+const LOOSE = /^[ \t\n\v\f\r]|[ \t\n\v\f\r]$|[ \t\n\v\f\r]{2}/;
+/**
+* Text as a resource holds it: XML's escapes, then Android's (`\`, `'`, `"`, a newline or a tab).
+* In a string that is formatted, `%` is doubled, so `String.format` writes one.
+*/
+function escape$1(text, formatted) {
+	const out = text.replaceAll("\\", "\\\\").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("'", "\\'").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("	", "\\t");
+	return formatted ? out.replaceAll("%", "%%") : out;
+}
+/**
+* A whole value: a leading `@` or `?` escaped, since either would make it a reference, and the value
+* quoted where its spaces would otherwise be collapsed or trimmed.
+*/
+function value$3(written) {
+	const out = /^[@?]/.test(written) ? `\\${written}` : written;
+	return LOOSE.test(out) ? `"${out}"` : out;
+}
+const PRINTF$1 = {
+	platform: "Android",
+	formatter: "String.format",
+	holder: "Android resources",
+	string: "s",
+	escape: escape$1,
+	plural: (name) => `{${name}} is a second plural in the message, and Android's <plurals> picks on one count: split it into a key per count, ${LEAVE_OUT}`
+};
+/**
+* A message as `<string>`, or `<plurals>` when it holds a plural. Android's picks between whole
+* messages, so the text around the plural goes into each arm: the pseudo-locale's brackets, or a
+* sentence the plural ends.
+*/
+function resource(name, ast, args) {
+	const at = ast.findIndex((el) => el.type === TYPE$1.plural);
+	const plural = ast[at];
+	if (plural?.type !== TYPE$1.plural) {
+		const written = formatString(ast, args, PRINTF$1);
+		return `    <string name="${name}"${args.length === 0 && written.includes("%") ? " formatted=\"false\"" : ""}>${value$3(written)}</string>`;
+	}
+	const [before, after] = [ast.slice(0, at), ast.slice(at + 1)];
+	const named = `{${plural.value}}`;
+	if (plural.pluralType === "ordinal") throw new Error(`${named} is an ordinal, and Android's <plurals> are cardinal only: write a key per case and pick one in code, ${LEAVE_OUT}`);
+	if (plural.offset !== 0) throw new Error(`${named} has an offset, which Android's <plurals> don't: count without it, and say the rest in each arm, ${LEAVE_OUT}`);
+	const selection = selectionOf(plural);
+	if (selection !== void 0 && (selection.fn.name !== "integer" || Object.keys(selection.fn.options).length > 0)) throw new Error(`${named} selects with :${selection.fn.name} and its options, and Android selects on the count as an integer: select with a bare :number or :integer, ${LEAVE_OUT}`);
+	const exact = Object.keys(plural.options).filter((k) => k.startsWith("="));
+	if (exact.length > 0) throw new Error(`${named} has the arm ${exact.join(", ")}, and Android's <plurals> have none for one number (its zero is a category, which most languages never pick): say it in a category's arm, or write a key for it and pick that in code, ${LEAVE_OUT}`);
+	return `    <plurals name="${name}">\n${Object.entries(plural.options).map(([category, option]) => `        <item quantity="${category}">${value$3(formatString([
+		...before,
+		...option.value,
+		...after
+	], args, PRINTF$1, plural.value))}</item>`).join("\n")}\n    </plurals>`;
+}
+/** The context and what each argument holds, as the comment above an entry. */
+function comment(m) {
+	const said = noteOf(m);
+	return said === "" ? "" : `    <!-- ${said.replace(/-{2,}/g, "-")} -->\n`;
+}
+/** The files `target` writes, by path, or a problem for every message it can't hold. */
+function androidResources(target, catalog, locales, entries, banner) {
+	const source = locales[0];
+	const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
+	const taken = catalog.messages.flatMap((m) => {
+		const words = wordsFor(target, m.key);
+		return words === void 0 ? [] : [{
+			m,
+			name: leading(snake(words))
+		}];
+	});
+	checkNames("android", taken.map(({ m, name }) => [m.key, name]), []);
+	const problems = taken.filter((t) => KEYWORDS$3.has(t.name)).map(({ m, name }) => ({
+		severity: "error",
+		file: m.file,
+		key: m.key,
+		message: `android: ${m.key} is named ${name}, which Java keeps for itself: rename it`
+	}));
+	const bodies = new Map(locales.map((l) => [l, []]));
+	const failed = /* @__PURE__ */ new Set();
+	for (const { m, name } of taken) {
+		const args = [...m.args.keys()];
+		const written = /* @__PURE__ */ new Map();
+		for (const locale of locales) {
+			const found = foundIn(m.key, locale, locales, asts);
+			if (failed.has(m.key)) break;
+			if (found === void 0) continue;
+			let entry = written.get(found);
+			if (entry === void 0) {
+				try {
+					entry = `${comment(m)}${resource(name, asts.get(found).get(m.key), args)}`;
+				} catch (e) {
+					failed.add(m.key);
+					problems.push({
+						severity: "error",
+						file: fileOf(m, found, source),
+						key: m.key,
+						message: `android: ${e.message}`
+					});
+					continue;
+				}
+				written.set(found, entry);
+			}
+			bodies.get(locale).push(entry);
+		}
+	}
+	const head = `<!-- ${banner.replace(/^\/\/ /, "")} -->`;
+	return {
+		files: new Map(locales.map((locale) => {
+			const folder = locale === source ? "values" : `values-${qualifierOf(locale)}`;
+			const body = bodies.get(locale).join("\n");
+			const xml = `<?xml version="1.0" encoding="utf-8"?>\n${head}\n<resources>\n${body}${body === "" ? "" : "\n"}</resources>\n`;
+			return [join(target.out, folder, `${target.name}.xml`), xml];
+		})),
+		problems
+	};
+}
+// src/tools/native/apple.ts
+/**
+* The catalog as Apple `.strings` tables: `<locale>.lproj/<name>.strings` per locale, each holding
+* what that locale shows, every fallback resolved. Plain `.strings` and not a String Catalog, which
+* only Xcode compiles: an app bundled by other tools copies these into its `Resources` as they are.
+*
+* The Swift target covers what code shows; these are for what the system reads from a bundle. With
+* `plist`, the table is `InfoPlist`: the permission prompts and names in that Info.plist, an entry
+* per key it has, which its own text must match in the source locale.
+*/
+/** Text inside a `.strings` file's quotes; `%` doubled where the string has arguments. */
+function escape(text, formatted) {
+	const out = text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t");
+	return formatted ? out.replaceAll("%", "%%") : out;
+}
+const PRINTF = {
+	platform: "Apple",
+	formatter: "String(format:)",
+	holder: ".strings files",
+	string: "@",
+	escape,
+	plural: (name) => `{${name}} is a plural, which a .strings file can't hold (it takes a .stringsdict, which this target doesn't write): show it from the Swift target, ${LEAVE_OUT}`
+};
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+/** An XML plist's string values by key, read as its text is: every `<key>` followed by a `<string>`. */
+function plistStrings(xml) {
+	const strings = /* @__PURE__ */ new Map();
+	for (const [, key, value] of xml.matchAll(/<key>([^<]*)<\/key>\s*(?:<string>([^<]*)<\/string>|<string\/>)/g)) strings.set(key, (value ?? "").replace(/&(amp|lt|gt|quot|apos|#x?[0-9a-f]+);/gi, (_, e) => e.startsWith("#") ? String.fromCodePoint(Number.parseInt(e.slice(/x/i.test(e[1]) ? 2 : 1), /x/i.test(e[1]) ? 16 : 10)) : ENTITIES[e.toLowerCase()]));
+	return strings;
+}
+/** The files `target` writes, by path, or a problem for every message it can't hold. */
+function appleStrings(target, root, catalog, locales, entries, banner) {
+	const source = locales[0];
+	const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
+	const problems = [];
+	const error = (m, message, file = m.file) => problems.push({
+		severity: "error",
+		file,
+		key: m.key,
+		message: `apple: ${message}`
+	});
+	const plist = target.plist;
+	const shown = plist === void 0 ? "" : relative(root, plist).replaceAll("\\", "/");
+	if (plist !== void 0 && !existsSync(plist)) throw new Error(`apple: ${shown} is missing: name the Info.plist the table translates`);
+	const strings = plist === void 0 ? void 0 : plistStrings(readFileSync(plist, "utf8"));
+	const byLower = new Map([...strings?.keys() ?? []].map((k) => [k.toLowerCase(), k]));
+	const taken = catalog.messages.flatMap((m) => {
+		const rest = restOf(target, m.key);
+		if (rest === void 0) return [];
+		if (strings === void 0) return [{
+			m,
+			name: rest
+		}];
+		const name = byLower.get(wordsFor(target, m.key).join("").toLowerCase());
+		if (name === void 0) {
+			error(m, `${m.key} names no string in ${shown}: spell one of its keys, as ns-camera-usage-description is NSCameraUsageDescription, or add it there`);
+			return [];
+		}
+		return [{
+			m,
+			name
+		}];
+	});
+	checkNames("apple", taken.map(({ m, name }) => [m.key, name]), []);
+	for (const { m, name } of taken) {
+		if (strings === void 0) continue;
+		if (m.args.size > 0) {
+			error(m, `${name} is shown as it is written, with nothing filled in: say it without {${[...m.args.keys()].join("}, {")}}`);
+			continue;
+		}
+		const text = staticLiteral(asts.get(source)?.get(m.key) ?? []);
+		if (text !== void 0 && text !== strings.get(name)) error(m, `${shown} says ${JSON.stringify(strings.get(name))} for ${name}: make it ${JSON.stringify(text)}, as the catalog says`);
+	}
+	const lines = new Map(locales.map((l) => [l, []]));
+	const failed = new Set(problems.map((p) => p.key));
+	for (const { m, name } of taken) {
+		if (failed.has(m.key)) continue;
+		const args = [...m.args.keys()];
+		const note = noteOf(m);
+		const head = note === "" ? "" : `/* ${note.replaceAll("*/", "* /")} */\n`;
+		const written = /* @__PURE__ */ new Map();
+		for (const locale of locales) {
+			const found = foundIn(m.key, locale, locales, asts);
+			if (found === void 0) continue;
+			let entry = written.get(found);
+			if (entry === void 0) {
+				try {
+					entry = `${head}"${escape(name, false)}" = "${formatString(asts.get(found).get(m.key), args, PRINTF)}";\n`;
+				} catch (e) {
+					error(m, e.message, fileOf(m, found, source));
+					break;
+				}
+				written.set(found, entry);
+			}
+			lines.get(locale).push(entry);
+		}
+	}
+	const top = `/* ${banner.replace(/^\/\/ /, "")} */\n`;
+	return {
+		files: new Map(locales.map((locale) => [join(target.out, `${locale}.lproj`, `${target.name}.strings`), [top, ...lines.get(locale)].join("\n")])),
+		problems
+	};
+}
+// src/tools/native/kotlin.ts
+const KEYWORDS$2 = new Set("as break class continue do else false for fun if in interface is null object package return super this throw true try typealias typeof val var when while".split(" "));
+const ident$2 = (name) => KEYWORDS$2.has(name) ? `\`${name}\`` : name;
+const lit$2 = (value) => stringLiteral(value, "kotlin");
+const entry = (tag) => leading(upper(wordsOf(tag)));
+const argName$2 = (name) => ident$2(leading(camel(wordsOf(name))));
+function doc$3(lines, indent) {
+	return `${indent}/**\n${lines.map((l) => l.replaceAll("*/", "*\\/")).map((l) => l === "" ? `${indent} *` : `${indent} * ${l}`).join("\n")}\n${indent} */\n`;
+}
+/** The parts as an expression of type `String`, with `rt` the runtime object. */
+function expr$2(parts, indent, rt) {
+	if (parts.length === 0) return "\"\"";
+	return parts.map((p) => p.type === "text" ? lit$2(p.value) : value$2(p, indent, rt)).join(" + ");
+}
+function value$2(part, indent, rt) {
+	const inner = `${indent}    `;
+	if (part.type === "string") return argName$2(part.arg);
+	if (part.type === "number") return `${rt}.number(${part.offset === 0 ? argName$2(part.arg) : `${argName$2(part.arg)} - ${float(part.offset)}`}, ${rt}.F${part.format}, ${lit$2(part.fallback)})`;
+	if (part.type === "select") {
+		const arms = part.arms.map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
+		return `when (${argName$2(part.arg)}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
+	}
+	if (part.arms.length + part.exact.length === 0) return expr$2(part.other, indent, rt);
+	const arg = argName$2(part.arg);
+	const on = part.on === "round" ? `${rt}.round(${arg})` : part.on === "percent" ? `${arg} * 100.0` : arg;
+	const { minFrac, maxFrac } = part.rounding;
+	const exact = part.exact.map((e) => `${float(e.value)} to ${lit$2(`=${e.value}`)}`).join(", ");
+	const arms = [...part.exact.map((e) => ({
+		key: `=${e.value}`,
+		parts: e.parts
+	})), ...part.arms].map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
+	return `when (${`${rt}.plural(${on}, ${float(part.offset)}, listOf(${exact}), ${rt}::r${part.rules}, ${minFrac}, ${maxFrac})`}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
+}
+function member$1(m, name, rt) {
+	const branches = m.bodies.map((b) => `            ${b.locales.map(entry).join(", ")} -> ${expr$2(b.parts, "            ", rt)}\n`).join("");
+	const argDocs = m.args.filter((a) => a.doc !== void 0).map((a) => `@param ${argName$2(a.name)} ${a.doc}`);
+	const head = doc$3(argDocs.length > 0 ? [
+		...m.doc,
+		"",
+		...argDocs
+	] : m.doc, "    ");
+	const body = `when (this) {\n${branches}        }`;
+	if (m.args.length === 0) return `${head}    val ${name}: String\n        get() = ${body}\n`;
+	return `${head}    fun ${name}(${m.args.map((a) => `${argName$2(a.name)}: ${a.type === "number" ? "Number" : "String"}`).join(", ")}): String {\n${m.args.filter((a) => a.type === "number").map((a) => `        val ${argName$2(a.name)} = ${argName$2(a.name)}.toDouble()\n`).join("")}        return ${body}\n    }\n`;
+}
+function formatConst$2(spec, i) {
+	const affix = ([prefix, suffix]) => `${lit$2(prefix)} to ${lit$2(suffix)}`;
+	return `    val F${i} = Format(\n${[
+		spec.minInt,
+		spec.minFrac,
+		spec.maxFrac,
+		spec.shift,
+		spec.grouping.primary,
+		spec.grouping.secondary,
+		spec.grouping.min,
+		lit$2(spec.decimal),
+		lit$2(spec.group),
+		spec.digits === void 0 ? "null" : `listOf(${spec.digits.map(lit$2).join(", ")})`,
+		affix(spec.positive),
+		affix(spec.negative),
+		affix(spec.zero),
+		affix(spec.negativeZero),
+		lit$2(spec.infinity),
+		lit$2(spec.negativeInfinity)
+	].map((f) => `        ${f}`).join(",\n")},\n    )\n`;
+}
+const NUMBER$2 = `
+    /** A number format, taken apart when the file was generated. */
+    class Format(
+        val minInt: Int,
+        val minFrac: Int,
+        val maxFrac: Int,
+        val shift: Int,
+        val primary: Int,
+        val secondary: Int,
+        val minGroup: Int,
+        val decimal: String,
+        val group: String,
+        val digits: List<String>?,
+        val positive: Pair<String, String>,
+        val negative: Pair<String, String>,
+        val zero: Pair<String, String>,
+        val negativeZero: Pair<String, String>,
+        val infinity: String,
+        val negativeInfinity: String,
+    )
+
+    /** \`value\` as \`format\` writes it, or \`fallback\` where it isn't a number. */
+    fun number(value: Double, format: Format, fallback: String): String {
+        if (value.isNaN()) return fallback
+        if (value.isInfinite()) return if (value > 0) format.infinity else format.negativeInfinity
+        val (written, frac) = digits(Math.abs(value), format.shift, format.minFrac, format.maxFrac)
+        val zero = (written + frac).all { it == '0' }
+        val negative = value.toRawBits() < 0
+        val (prefix, suffix) = if (zero) (if (negative) format.negativeZero else format.zero) else (if (negative) format.negative else format.positive)
+        val int = written.padStart(maxOf(format.minInt, 1), '0')
+        val grouped = format.minGroup > 0 && int.length >= format.primary + format.minGroup
+        val out = StringBuilder(prefix)
+        for ((i, digit) in int.withIndex()) {
+            val left = int.length - i
+            if (grouped && i > 0 && (left == format.primary || (left > format.primary && (left - format.primary) % format.secondary == 0))) {
+                out.append(format.group)
+            }
+            out.append(shown(digit, format))
+        }
+        if (frac.isNotEmpty()) {
+            out.append(format.decimal)
+            for (digit in frac) out.append(shown(digit, format))
+        }
+        return out.append(suffix).toString()
+    }
+
+    private fun shown(digit: Char, format: Format): String = format.digits?.get(digit - '0') ?: digit.toString()
+
+    /**
+     * The shortest digits that read back as \`value\`, as \`Intl\` rounds them: moved \`shift\` places
+     * right, rounded half away from zero to \`max\` fraction digits, and trailing zeros cut to \`min\`.
+     */
+    fun digits(value: Double, shift: Int, min: Int, max: Int): Pair<String, String> {
+        // \`toString\` writes the shortest digits that read back, with an exponent past a size.
+        val plain = java.math.BigDecimal(value.toString()).toPlainString()
+        val int = plain.substringBefore('.')
+        val all = (int + plain.substringAfter('.', "")).map { it - '0' }.toMutableList()
+        var point = int.length + shift
+        while (all.size <= point + max) all.add(0)
+        val next = all[point + max]
+        while (all.size > point + max) all.removeAt(all.size - 1)
+        if (next >= 5) {
+            var at = all.size - 1
+            while (at >= 0 && all[at] == 9) all[at--] = 0
+            if (at < 0) {
+                all.add(0, 1)
+                point += 1
+            } else {
+                all[at] += 1
+            }
+        }
+        val frac = all.subList(point, all.size).toMutableList()
+        while (frac.size > min && frac.last() == 0) frac.removeAt(frac.size - 1)
+        return all.subList(0, point).dropWhile { it == 0 }.joinToString("") to frac.joinToString("")
+    }
+`;
+const PLURAL$2 = `
+    /** CLDR's plural operands of a number as written. */
+    class Operands(val n: Double, val i: Double, val v: Double, val w: Double, val f: Double, val t: Double, val c: Double, val e: Double)
+
+    /** The arm a plural takes: the \`=N\` that \`value\` equals, else the category of \`value\` less \`offset\`. */
+    fun plural(value: Double, offset: Double, exact: List<Pair<Double, String>>, rules: (Operands) -> String, min: Int, max: Int): String =
+        exact.firstOrNull { it.first == value }?.second ?: category(rules, value - offset, min, max)
+
+    /** The category \`rules\` give \`value\`, rounded to between \`min\` and \`max\` fraction digits. */
+    private fun category(rules: (Operands) -> String, value: Double, min: Int, max: Int): String {
+        if (!value.isFinite()) return "other"
+        val (written, frac) = digits(Math.abs(value), 0, min, max)
+        val int = written.ifEmpty { "0" }
+        val trimmed = frac.trimEnd('0')
+        val read = { s: String -> s.toDoubleOrNull() ?: 0.0 }
+        return rules(
+            Operands(
+                n = read(if (frac.isEmpty()) int else "$int.$frac"),
+                i = read(int),
+                v = frac.length.toDouble(),
+                w = trimmed.length.toDouble(),
+                f = read(frac),
+                t = read(trimmed),
+                c = 0.0,
+                e = 0.0,
+            ),
+        )
+    }
+
+    /** An integer in the range, as CLDR's ranges hold. */
+    private fun within(value: Double, from: Double, to: Double): Boolean = value % 1.0 == 0.0 && value >= from && value <= to
+
+    /** \`Math.round\`: half up, toward positive infinity. */
+    fun round(value: Double): Double {
+        val floor = Math.floor(value)
+        return if (value - floor >= 0.5) floor + 1 else floor
+    }
+`;
+function kotlinFile(model, target, banner) {
+	const name = target.name;
+	const rt = `${name}Runtime`;
+	const names = model.messages.map((m) => [m.key, ident$2(leading(camel(m.words)))]);
+	checkNames("kotlin", names, [
+		"tag",
+		"name",
+		"ordinal",
+		"entries",
+		"negotiate",
+		"SOURCE"
+	]);
+	const entries = model.locales.map((l) => `    /** \`${l}\`${l === model.source ? ", the source" : ""}. */\n    ${entry(l)}(${lit$2(l)})`).join(",\n");
+	const members = model.messages.map((m, i) => member$1(m, names[i][1], rt)).join("\n");
+	const rules = model.rules.map(({ name: rule, rules }, i) => {
+		return `    /** ${rule} */\n    fun r${i}(o: Operands): String {\n${rules.map(([category, condition]) => `        if (${conditionCode(condition, {
+			field: (op) => `o.${op}`,
+			mod: (v, by) => `${v} % ${by}`,
+			within: (v, from, to) => `within(${v}, ${from}, ${to})`
+		})}) return ${lit$2(category)}\n`).join("")}        return "other"\n    }\n`;
+	}).join("\n");
+	const runtime = model.formats.length + model.rules.length === 0 ? "" : `
+/** What formats the messages, generated with them. */
+private object ${rt} {${NUMBER$2}${model.rules.length > 0 ? PLURAL$2 : ""}
+${model.formats.map(formatConst$2).join("\n")}${rules === "" ? "" : `\n${rules}`}}
+`;
+	return `${banner}
+@file:Suppress("unused", "NAME_SHADOWING", "KotlinConstantConditions", "ConvertTwoComparisonsToRangeCheck")
+${target.package === void 0 ? "" : `\npackage ${target.package}\n`}
+/** A locale the catalog is written or translated in, and its messages. */
+enum class ${name}(val tag: String) {
+${entries};
+
+${members}
+    companion object {
+        /** The locale the catalog is written in, which every message falls back to. */
+        val SOURCE: ${name} = ${entry(model.source)}
+
+        /**
+         * The best locale for what was asked, most preferred first: each tag tries an exact match, then
+         * its parents (\`pt-BR\` finds \`pt\`), then any locale of its language. The source if none is.
+         */
+        fun negotiate(requested: List<String>): ${name} {
+            fun language(tag: String) = tag.substringBefore('-').lowercase()
+            for (want in requested) {
+                var tag = want
+                while (true) {
+                    entries.firstOrNull { it.tag.equals(tag, ignoreCase = true) }?.let { return it }
+                    val cut = tag.lastIndexOf('-')
+                    if (cut < 0) break
+                    tag = tag.substring(0, cut)
+                }
+                entries.firstOrNull { language(it.tag) == language(want) }?.let { return it }
+            }
+            return SOURCE
+        }
+    }
+}
+${runtime}`;
+}
+// src/tools/native/rust.ts
+const KEYWORDS$1 = new Set("as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while abstract become box do final macro override priv try typeof unsized virtual yield gen".split(" "));
+const ident$1 = (name) => KEYWORDS$1.has(name) ? `${name}_` : name;
+const lit$1 = (value) => stringLiteral(value, "rust");
+const variant = (tag) => pascal(wordsOf(tag));
+const argName$1 = (name) => ident$1(leading(snake(wordsOf(name))));
+function doc$2(lines, indent) {
+	return lines.map((l) => l === "" ? `${indent}///\n` : `${indent}/// ${l}\n`).join("");
+}
+/** The parts as an expression of type `String`. */
+function expr$1(parts, indent) {
+	if (parts.length === 0) return "String::new()";
 	const [only] = parts;
 	if (parts.length === 1 && only !== void 0) {
 		if (only.type === "text") return `String::from(${lit$1(only.value)})`;
@@ -4848,8 +5158,9 @@ ${runtime}`;
 }
 // src/tools/native/index.ts
 /**
-* The native files `generate` writes beside the TypeScript, one per target in the config's `native`.
-* A message a target can't render fails the build with the reason, as a translation that drifted does.
+* The native files `generate` writes beside the TypeScript, one per target in the config's `native`
+* (Android's and Apple's string resources, a file per locale). A message a target can't render
+* fails the build with the reason, as a translation that drifted does.
 */
 const WRITERS = {
 	rust: rustModule,
@@ -4859,18 +5170,22 @@ const WRITERS = {
 function nativeFiles(config, catalog, locales, entries, banner) {
 	const files = /* @__PURE__ */ new Map();
 	const problems = [];
-	for (const target of config.native) {
+	for (const target of config.native) try {
+		if (target.language === "android" || target.language === "apple") {
+			const { files: written, problems: found } = target.language === "android" ? androidResources(target, catalog, locales, entries, banner) : appleStrings(target, config.root, catalog, locales, entries, banner);
+			problems.push(...found);
+			for (const [path, content] of written) files.set(path, content);
+			continue;
+		}
 		const { model, problems: found } = nativeModel(target, catalog, locales, entries);
 		problems.push(...found);
 		if (found.length > 0) continue;
-		try {
-			files.set(target.out, WRITERS[target.language](model, target, banner));
-		} catch (e) {
-			problems.push({
-				severity: "error",
-				message: e.message
-			});
-		}
+		files.set(target.out, WRITERS[target.language](model, target, banner));
+	} catch (e) {
+		problems.push({
+			severity: "error",
+			message: e.message
+		});
 	}
 	if (problems.length > 0) throw new CatalogError(problems);
 	return files;
@@ -5170,4 +5485,4 @@ function generate(config, options = {}) {
 }
 export { writeMessage as A, entryLocation as C, whereOf as D, previewOf as E, toMf1 as F, intlNumber as M, parseMf2 as N, SYNTAX_NAME as O, toMf2 as P, KEY_PATTERN as S, loadCatalog as T, applyFixes as _, render as a, readEntry as b, pseudoText as c, hash as d, readLock as f, wordDiff as g, formatDiff as h, localesOf as i, intlDate as j, readMessage as k, changeOf as l, serializeLock as m, generate as n, writeFiles as o, reconcile as p, localeEntries as r, pseudoAst as s, catalogSchema as t, emptyLock as u, editEntry as v, entryLocator as w, CatalogError as x, importTranslations as y };
 
-//# sourceMappingURL=generate-9pR3i5Bj.js.map
+//# sourceMappingURL=generate-BW3N8EGb.js.map