prosebook 0.2.0 → 0.4.0

package/src/tools/native/kotlin.ts

@@ -0,0 +1,269 @@
+/**
+ * The model as a Kotlin file: an enum class of locales with a property or function per message, and
+ * a file-private object holding what formats them. For the JVM and Android.
+ */
+import type { NativeTarget } from '#src/tools/config.ts';
+import { camel, checkNames, conditionCode, float, leading, stringLiteral, upper, wordsOf } from './emit.ts';
+import type { NativeMessage, NativeModel, Part } from './model.ts';
+import type { NumberSpec } from './number.ts';
+
+const KEYWORDS = 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 = (name: string) => (KEYWORDS.has(name) ? `\`${name}\`` : name);
+const lit = (value: string) => stringLiteral(value, 'kotlin');
+const entry = (tag: string) => leading(upper(wordsOf(tag)));
+const argName = (name: string) => ident(leading(camel(wordsOf(name))));
+
+function doc(lines: string[], indent: string): string {
+  const safe = lines.map((l) => l.replaceAll('*/', '*\\/'));
+  return `${indent}/**\n${safe.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(parts: Part[], indent: string, rt: string): string {
+  if (parts.length === 0) return '""';
+  return parts.map((p) => (p.type === 'text' ? lit(p.value) : value(p, indent, rt))).join(' + ');
+}
+
+function value(part: Exclude<Part, { type: 'text' }>, indent: string, rt: string): string {
+  const inner = `${indent}    `;
+  if (part.type === 'string') return argName(part.arg);
+  if (part.type === 'number') {
+    const of = part.offset === 0 ? argName(part.arg) : `${argName(part.arg)} - ${float(part.offset)}`;
+    return `${rt}.number(${of}, ${rt}.F${part.format}, ${lit(part.fallback)})`;
+  }
+  if (part.type === 'select') {
+    const arms = part.arms.map((a) => `${inner}${lit(a.key)} -> ${expr(a.parts, inner, rt)}\n`).join('');
+    return `when (${argName(part.arg)}) {\n${arms}${inner}else -> ${expr(part.other, inner, rt)}\n${indent}}`;
+  }
+  // A plural, the one kind left. With only `other`, there is nothing to select on.
+  if (part.arms.length + part.exact.length === 0) return expr(part.other, indent, rt);
+  const arg = argName(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(`=${e.value}`)}`).join(', ');
+  const arms = [...part.exact.map((e) => ({ key: `=${e.value}`, parts: e.parts })), ...part.arms]
+    .map((a) => `${inner}${lit(a.key)} -> ${expr(a.parts, inner, rt)}\n`)
+    .join('');
+  const pick = `${rt}.plural(${on}, ${float(part.offset)}, listOf(${exact}), ${rt}::r${part.rules}, ${minFrac}, ${maxFrac})`;
+  return `when (${pick}) {\n${arms}${inner}else -> ${expr(part.other, inner, rt)}\n${indent}}`;
+}
+
+function member(m: NativeMessage, name: string, rt: string): string {
+  const branches = m.bodies.map((b) => `            ${b.locales.map(entry).join(', ')} -> ${expr(b.parts, '            ', rt)}\n`).join('');
+  const argDocs = m.args.filter((a) => a.doc !== undefined).map((a) => `@param ${argName(a.name)} ${a.doc}`);
+  const head = doc(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`;
+  const params = m.args.map((a) => `${argName(a.name)}: ${a.type === 'number' ? 'Number' : 'String'}`).join(', ');
+  const numbers = m.args
+    .filter((a) => a.type === 'number')
+    .map((a) => `        val ${argName(a.name)} = ${argName(a.name)}.toDouble()\n`)
+    .join('');
+  return `${head}    fun ${name}(${params}): String {\n${numbers}        return ${body}\n    }\n`;
+}
+
+function formatConst(spec: NumberSpec, i: number): string {
+  const affix = ([prefix, suffix]: readonly [string, string]) => `${lit(prefix)} to ${lit(suffix)}`;
+  const fields = [
+    spec.minInt,
+    spec.minFrac,
+    spec.maxFrac,
+    spec.shift,
+    spec.grouping.primary,
+    spec.grouping.secondary,
+    spec.grouping.min,
+    lit(spec.decimal),
+    lit(spec.group),
+    spec.digits === undefined ? 'null' : `listOf(${spec.digits.map(lit).join(', ')})`,
+    affix(spec.positive),
+    affix(spec.negative),
+    affix(spec.zero),
+    affix(spec.negativeZero),
+    lit(spec.infinity),
+    lit(spec.negativeInfinity),
+  ];
+  return `    val F${i} = Format(\n${fields.map((f) => `        ${f}`).join(',\n')},\n    )\n`;
+}
+
+const NUMBER = `
+    /** 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 = `
+    /** 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
+    }
+`;
+
+export function kotlinFile(model: NativeModel, target: NativeTarget & { name: string }, banner: string): string {
+  const name = target.name;
+  const rt = `${name}Runtime`;
+  const names = model.messages.map((m): [string, string] => [m.key, ident(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(l)})`)
+    .join(',\n');
+  const members = model.messages.map((m, i) => member(m, names[i]![1], rt)).join('\n');
+  const rules = model.rules
+    .map(({ name: rule, rules }, i) => {
+      const checks = 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(category)}\n`,
+      );
+      return `    /** ${rule} */\n    fun r${i}(o: Operands): String {\n${checks.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}${model.rules.length > 0 ? PLURAL : ''}
+${model.formats.map(formatConst).join('\n')}${rules === '' ? '' : `\n${rules}`}}
+`;
+
+  return `${banner}
+@file:Suppress("unused", "NAME_SHADOWING", "KotlinConstantConditions", "ConvertTwoComparisonsToRangeCheck")
+${target.package === undefined ? '' : `\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}`;
+}

package/src/tools/native/model.ts

@@ -0,0 +1,292 @@
+/**
+ * The catalog as a native target writes it, before any language: per message, its arguments and one
+ * 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.
+ */
+import { isDateElement, isNumberElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
+
+import { chainOf } from '#src/runtime/locale.ts';
+import type { Catalog, Message, Problem } from '#src/tools/catalog.ts';
+import type { Entry } from '#src/tools/compile.ts';
+import type { NativeTarget } from '#src/tools/config.ts';
+import { numberOptions, optionArgsOf, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { docText } from './emit.ts';
+import { numberSpec, roundingOf, type NumberSpec, type Rounding } from './number.ts';
+import { pluralRules, type PluralRules } from './plurals.ts';
+
+export type Part =
+  | { type: 'text'; value: string }
+  | { type: 'string'; arg: string }
+  /** The argument less `offset`, in format `format`; `fallback` where it isn't a number. */
+  | { type: 'number'; arg: string; offset: number; format: number; fallback: string }
+  | { type: 'select'; arg: string; arms: Arm[]; other: Part[] }
+  | {
+      type: 'plural';
+      arg: string;
+      /** What it selects on: the value, rounded as `Math.round` does (MF2's `:integer`), or as a percent. */
+      on: 'value' | 'round' | 'percent';
+      offset: number;
+      /** `=N` arms, matched on the value before its offset. */
+      exact: { value: number; parts: Part[] }[];
+      rules: number;
+      rounding: Rounding;
+      arms: Arm[];
+      other: Part[];
+    };
+
+export interface Arm {
+  key: string;
+  parts: Part[];
+}
+
+export interface NativeMessage {
+  key: string;
+  /** The key less the prefix that took it in, as words: `tray.quit-app` is tray, quit, app. */
+  words: string[];
+  /** The source text, its context, and what's asked of it. */
+  doc: string[];
+  args: { name: string; type: 'string' | 'number'; doc?: string }[];
+  /** A tree per locale that renders it its own way; every locale is in one. */
+  bodies: { locales: string[]; parts: Part[] }[];
+}
+
+export interface NativeModel {
+  /** Every locale, the source first. */
+  locales: string[];
+  source: string;
+  messages: NativeMessage[];
+  formats: NumberSpec[];
+  rules: { name: string; rules: PluralRules }[];
+}
+
+/**
+ * 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.
+ */
+export function wordsFor(target: NativeTarget, key: string): string[] | undefined {
+  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']`. */
+export function restOf(target: NativeTarget, key: string): string | undefined {
+  const prefix = target.keys === undefined ? '' : [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+  if (prefix === undefined) return undefined;
+  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. */
+export function foundIn(key: string, locale: string, locales: string[], asts: Map<string, Map<string, MessageFormatElement[]>>) {
+  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. */
+class Numbered<T> {
+  readonly list: T[] = [];
+  private readonly byJson = new Map<string, number>();
+
+  add(value: T, json = JSON.stringify(value)): number {
+    let at = this.byJson.get(json);
+    if (at === undefined) {
+      this.byJson.set(json, (at = this.list.length));
+      this.list.push(value);
+    }
+    return at;
+  }
+}
+
+/** The model of what `target` takes from the catalog, with a problem for every message it can't render. */
+export function nativeModel(
+  target: NativeTarget,
+  catalog: Catalog,
+  locales: string[],
+  entries: Map<string, Entry[]>,
+): { model: NativeModel; problems: Problem[] } {
+  const source = locales[0]!;
+  const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
+  const formats = new Numbered<NumberSpec>();
+  const rules = new Numbered<{ name: string; rules: PluralRules }>();
+  const problems: Problem[] = [];
+  const messages: NativeMessage[] = [];
+
+  for (const m of catalog.messages) {
+    const words = wordsFor(target, m.key);
+    if (words === undefined) continue;
+    const bodies = new Map<string, { locales: string[]; parts: Part[] }>();
+    let failed = false;
+    for (const locale of locales) {
+      const found = foundIn(m.key, locale, locales, asts);
+      if (found === undefined) continue;
+      const body = bodies.get(found);
+      if (body !== undefined) {
+        body.locales.push(locale);
+        continue;
+      }
+      try {
+        bodies.set(found, { locales: [locale], parts: parts(asts.get(found)!.get(m.key)!, found, formats, rules, null) });
+      } catch (e) {
+        failed = true;
+        problems.push({
+          severity: 'error',
+          file: fileOf(m, found, source),
+          key: m.key,
+          message: `${target.language}: ${(e as Error).message}`,
+        });
+      }
+    }
+    if (failed) continue;
+    messages.push({
+      key: m.key,
+      words,
+      doc: docOf(m),
+      args: [...m.args].map(([name, type]) => ({
+        name,
+        type: type === 'number' ? 'number' : 'string',
+        doc: m.argDocs.has(name) ? docText(m.argDocs.get(name)!) : undefined,
+      })),
+      bodies: [...bodies.values()],
+    });
+  }
+  return { model: { locales, source, messages, formats: formats.list, rules: rules.list }, problems };
+}
+
+export function fileOf(m: Message, locale: string, source: string): string {
+  return locale === source ? m.file : (m.translations.get(locale)?.file ?? m.file);
+}
+
+function docOf(m: Message): string[] {
+  const lines = (m.text.length > 400 ? `${m.text.slice(0, 397)}...` : m.text).split('\n');
+  if (m.context) lines.push('', m.context);
+  if (m.remove) lines.push('', 'Marked for removal in the catalog.');
+  if (m.comment) lines.push('', `Comment: ${m.comment}`);
+  return lines.map(docText);
+}
+
+export const LEAVE_OUT = "or leave the key out of this target's `keys`";
+
+/** Specs by locale and options, kept across runs: taking a format apart checks it against `Intl` dozens of times. */
+const SPECS = new Map<string, NumberSpec | Error>();
+
+function format(formats: Numbered<NumberSpec>, locale: string, options: Intl.NumberFormatOptions | undefined): number {
+  const key = JSON.stringify([locale, options ?? {}]);
+  let spec = SPECS.get(key);
+  if (spec === undefined) {
+    try {
+      spec = numberSpec(locale, options);
+    } catch (e) {
+      spec = new Error(`native code can't format this number in ${locale}: ${(e as Error).message}. Format it another way, ${LEAVE_OUT}`, {
+        cause: e,
+      });
+    }
+    SPECS.set(key, spec);
+  }
+  if (spec instanceof Error) throw spec;
+  return formats.add(spec);
+}
+
+type Pound = { arg: string; offset: number } | null;
+
+function parts(
+  elements: MessageFormatElement[],
+  locale: string,
+  formats: Numbered<NumberSpec>,
+  rules: Numbered<{ name: string; rules: PluralRules }>,
+  pound: Pound,
+): Part[] {
+  const out: Part[] = [];
+  const text = (value: string) => {
+    const last = out.at(-1);
+    if (last?.type === 'text') last.value += value;
+    else if (value !== '') out.push({ type: 'text', value });
+  };
+  const placed = (el: MessageFormatElement, name: string, part: Part) => {
+    const { isolate } = placeholderOf(el, name);
+    if (isolate !== undefined) text(isolate[0]);
+    out.push(part);
+    if (isolate !== undefined) text(isolate[1]);
+  };
+  const arms = (options: Record<string, { value: MessageFormatElement[] }>, own: Pound) =>
+    Object.entries(options).map(([key, option]) => ({ key, parts: parts(option.value, locale, formats, rules, own) }));
+
+  for (const el of elements) {
+    if (Object.keys(optionArgsOf(el) ?? {}).length > 0) {
+      throw new Error(
+        `{${'value' in el ? el.value : ''}} takes a formatting option from an argument: native code formats with options the message fixes, ${LEAVE_OUT}`,
+      );
+    }
+    if (isDateElement(el) || isTimeElement(el)) {
+      throw new Error(
+        `{${el.value}} is a date, which native code doesn't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`,
+      );
+    }
+    if (isNumberElement(el)) {
+      const fallback = placeholderOf(el, el.value).fallback;
+      placed(el, el.value, { type: 'number', arg: el.value, offset: 0, format: format(formats, locale, numberOptions(el)), fallback });
+      continue;
+    }
+    switch (el.type) {
+      case TYPE.literal:
+        text(el.value);
+        break;
+      case TYPE.argument:
+        placed(el, el.value, { type: 'string', arg: el.value });
+        break;
+      case TYPE.pound:
+        if (pound === null) {
+          text('#');
+          break;
+        }
+        placed(el, pound.arg, {
+          type: 'number',
+          arg: pound.arg,
+          offset: pound.offset,
+          format: format(formats, locale, undefined),
+          fallback: placeholderOf(el, pound.arg).fallback,
+        });
+        break;
+      case TYPE.select: {
+        const all = arms(el.options, pound);
+        out.push({
+          type: 'select',
+          arg: el.value,
+          arms: all.filter((a) => a.key !== 'other'),
+          other: all.find((a) => a.key === 'other')!.parts,
+        });
+        break;
+      }
+      case TYPE.plural: {
+        const selection = selectionOf(el);
+        const type = el.pluralType === 'ordinal' ? 'ordinal' : 'cardinal';
+        const all = arms(el.options, { arg: el.value, offset: el.offset });
+        let rounding: Rounding;
+        try {
+          rounding = roundingOf(locale, { ...selection?.options, type });
+        } catch (e) {
+          throw new Error(`{${el.value}} can't select in native code: ${(e as Error).message}, ${LEAVE_OUT}`, { cause: e });
+        }
+        const found = pluralRules(locale, type);
+        out.push({
+          type: 'plural',
+          arg: el.value,
+          on: selection?.value ?? 'value',
+          offset: el.offset,
+          // Matched as the runtime does, by the value's own `String()`, so `=1.50` never matches.
+          exact: all
+            .filter((a) => a.key.startsWith('=') && String(Number(a.key.slice(1))) === a.key.slice(1))
+            .map((a) => ({ value: Number(a.key.slice(1)), parts: a.parts })),
+          rules: rules.add({ name: `${type}, as ${locale} has them`, rules: found }, JSON.stringify(found)),
+          rounding,
+          arms: all.filter((a) => !a.key.startsWith('=') && a.key !== 'other'),
+          other: all.find((a) => a.key === 'other')!.parts,
+        });
+        break;
+      }
+      case TYPE.tag:
+        throw new Error(`<${el.value}> is a tag, and native code writes plain text: say it without the tag, ${LEAVE_OUT}`);
+      default:
+        throw new Error(`prosebook: no native writer for ICU element type ${(el as MessageFormatElement).type}`);
+    }
+  }
+  return out;
+}