prosebook 0.2.0 → 0.3.0

package/src/tools/native/number.ts

@@ -0,0 +1,210 @@
+/**
+ * A number format taken apart at build time, so native code can put it back together with no
+ * formatter of its own: the digits to round to, the symbols, how integers group, and the text around
+ * the number for each sign. Read from `Intl.NumberFormat` and checked against it before any code is
+ * written, so a native target says what the browser says, or the build says why it can't.
+ */
+
+/** The text before and after the number. */
+export type Affix = readonly [prefix: string, suffix: string];
+
+export interface NumberSpec {
+  minInt: number;
+  minFrac: number;
+  maxFrac: number;
+  /** How far the decimal point moves right before rounding: 2 for a percent. */
+  shift: number;
+  /** Integer digits grouped from the right, `primary` then `secondary` at a time, once there are `primary + min` of them; `min` 0 never groups. */
+  grouping: { primary: number; secondary: number; min: number };
+  decimal: string;
+  group: string;
+  /** The numbering system's digits, 0 to 9, where it isn't ASCII's. */
+  digits?: string[];
+  positive: Affix;
+  negative: Affix;
+  /** A value that rounds to zero, by its sign. */
+  zero: Affix;
+  negativeZero: Affix;
+  nan: string;
+  infinity: string;
+  negativeInfinity: string;
+}
+
+/** The plural operands' digits: rounded as `Intl.PluralRules` rounds before it selects. */
+export interface Rounding {
+  minFrac: number;
+  maxFrac: number;
+}
+
+const NUMBER_PARTS = new Set(['integer', 'group', 'decimal', 'fraction']);
+
+/** Values the spec must format as `Intl` does: signs, zeros, ties, grouping thresholds, every plural form a unit could take. */
+const SAMPLES = [
+  0,
+  -0,
+  1,
+  -1,
+  2,
+  3,
+  5,
+  11,
+  21,
+  0.5,
+  1.5,
+  2.5,
+  -2.5,
+  0.125,
+  0.0001,
+  -0.0001,
+  0.07,
+  1.005,
+  12.345,
+  999.9999,
+  1000,
+  10000,
+  100000,
+  1234.5678,
+  -1234.5678,
+  1e6,
+  123456789.987,
+  1e21,
+  NaN,
+  Infinity,
+  -Infinity,
+];
+
+function affixOf(parts: Intl.NumberFormatPart[]): Affix {
+  const first = parts.findIndex((p) => NUMBER_PARTS.has(p.type));
+  const last = parts.findLastIndex((p) => NUMBER_PARTS.has(p.type));
+  const text = (from: number, to: number) =>
+    parts
+      .slice(from, to)
+      .map((p) => p.value)
+      .join('');
+  return [text(0, first), text(last + 1, parts.length)];
+}
+
+function partOf(parts: Intl.NumberFormatPart[], type: string): string | undefined {
+  return parts.find((p) => p.type === type)?.value;
+}
+
+/**
+ * What a format with `options` takes in `locale`. Throws a sentence saying what a native target
+ * can't reproduce, which the caller puts in front of a fix.
+ */
+export function numberSpec(locale: string, options: Intl.NumberFormatOptions = {}): NumberSpec {
+  const format = new Intl.NumberFormat(locale, options);
+  const resolved = format.resolvedOptions();
+  if (resolved.notation !== 'standard') throw new Error(`${resolved.notation} notation reads the size of the number at runtime`);
+  if (resolved.minimumSignificantDigits !== undefined) throw new Error('significant digits round by the size of the number');
+  if (resolved.roundingIncrement !== 1 || resolved.roundingMode !== 'halfExpand')
+    throw new Error('it rounds other than half away from zero');
+  if (resolved.trailingZeroDisplay !== 'auto') throw new Error('it drops trailing zeros by value');
+
+  const at = (more: Intl.NumberFormatOptions) => new Intl.NumberFormat(locale, { ...options, ...more });
+  const whole = at({ minimumFractionDigits: 0, maximumFractionDigits: 0 });
+  const integers = whole
+    .formatToParts(1234567891234)
+    .filter((p) => p.type === 'integer')
+    .map((p) => p.value.length);
+  const grouped = (digits: number) =>
+    whole.formatToParts(10 ** (digits - 1 - (resolved.style === 'percent' ? 2 : 0))).some((p) => p.type === 'group');
+  const primary = integers.at(-1) ?? 3;
+  const secondary = integers.length > 2 ? integers.at(-2)! : primary;
+  const min = integers.length < 2 ? 0 : ([1, 2, 3, 4].find((m) => grouped(primary + m)) ?? 0);
+
+  const native = new Intl.NumberFormat(locale, { numberingSystem: resolved.numberingSystem, useGrouping: false });
+  const digits = Array.from({ length: 10 }, (_, d) => native.format(d));
+  const spec: NumberSpec = {
+    minInt: resolved.minimumIntegerDigits,
+    minFrac: resolved.minimumFractionDigits ?? 0,
+    maxFrac: resolved.maximumFractionDigits ?? 0,
+    shift: resolved.style === 'percent' ? 2 : 0,
+    grouping: { primary, secondary, min },
+    decimal: partOf(at({ minimumFractionDigits: 1, maximumFractionDigits: 1 }).formatToParts(1.5), 'decimal') ?? '.',
+    group: partOf(whole.formatToParts(1234567891234), 'group') ?? ',',
+    ...(digits.join('') !== '0123456789' && { digits }),
+    positive: affixOf(format.formatToParts(1)),
+    negative: affixOf(format.formatToParts(-1)),
+    zero: affixOf(format.formatToParts(0)),
+    negativeZero: affixOf(format.formatToParts(-0)),
+    nan: format.format(NaN),
+    infinity: format.format(Infinity),
+    negativeInfinity: format.format(-Infinity),
+  };
+  for (const sample of SAMPLES) {
+    const expected = format.format(sample);
+    const actual = formatNumber(spec, sample);
+    if (actual !== expected) throw new Error(`it writes ${sample} as "${expected}", which native code would write as "${actual}"`);
+  }
+  return spec;
+}
+
+/** How `Intl.PluralRules` rounds before it selects, with `options` (MF2's selector options) in `locale`. */
+export function roundingOf(locale: string, options: Intl.PluralRulesOptions = {}): Rounding {
+  const resolved = new Intl.PluralRules(locale, options).resolvedOptions();
+  if (resolved.minimumSignificantDigits !== undefined) throw new Error('significant digits select by the size of the number');
+  return { minFrac: resolved.minimumFractionDigits ?? 0, maxFrac: resolved.maximumFractionDigits ?? 3 };
+}
+
+/**
+ * The digits of a finite, non-negative double as the shortest decimal that reads back as it, which
+ * is what `Intl` rounds: 1.005 is 1.00499… in binary, and still rounds to 1.01. Every target's
+ * shortest form (`String()` here) may use an exponent, which moves the point.
+ */
+export function shortestDigits(value: number): { int: string; frac: string } {
+  const [mantissa = '', exponent = '0'] = String(value).split('e');
+  const [int = '', frac = ''] = mantissa.split('.');
+  const point = int.length + Number(exponent);
+  const all = int + frac;
+  if (point <= 0) return { int: '0', frac: '0'.repeat(-point) + all };
+  return { int: all.slice(0, point).padEnd(point, '0'), frac: all.slice(point) };
+}
+
+/**
+ * Exact digits moved `shift` places right, rounded half away from zero to `maxFrac`, with trailing
+ * zeros cut down to `minFrac`. The algorithm every target writes out; keep them in step.
+ */
+export function roundDigits(int: string, frac: string, shift: number, minFrac: number, maxFrac: number): { int: string; frac: string } {
+  const padded = frac.padEnd(shift, '0');
+  const whole = int + padded.slice(0, shift);
+  const rest = padded.slice(shift);
+  const kept = (whole + rest.slice(0, maxFrac).padEnd(maxFrac, '0')).split('').map(Number);
+  if ((rest[maxFrac] ?? '0') >= '5') {
+    let at = kept.length - 1;
+    while (at >= 0 && kept[at] === 9) kept[at--] = 0;
+    if (at < 0) kept.unshift(1);
+    else kept[at]!++;
+  }
+  const all = kept.join('');
+  let outFrac = all.slice(all.length - maxFrac);
+  while (outFrac.length > minFrac && outFrac.endsWith('0')) outFrac = outFrac.slice(0, -1);
+  return { int: all.slice(0, all.length - maxFrac).replace(/^0+/, ''), frac: outFrac };
+}
+
+function groupDigits(int: string, { primary, secondary, min }: NumberSpec['grouping'], separator: string): string {
+  if (min === 0 || int.length < primary + min) return int;
+  const groups = [int.slice(-primary)];
+  let rest = int.slice(0, -primary);
+  while (rest.length > secondary) {
+    groups.unshift(rest.slice(-secondary));
+    rest = rest.slice(0, -secondary);
+  }
+  groups.unshift(rest);
+  return groups.join(separator);
+}
+
+/** `value` as the spec writes it: the reference for the code each target generates. */
+export function formatNumber(spec: NumberSpec, value: number): string {
+  if (Number.isNaN(value)) return spec.nan;
+  if (!Number.isFinite(value)) return value > 0 ? spec.infinity : spec.negativeInfinity;
+  const shortest = shortestDigits(Math.abs(value));
+  const { int, frac } = roundDigits(shortest.int, shortest.frac, spec.shift, spec.minFrac, spec.maxFrac);
+  const negative = value < 0 || Object.is(value, -0);
+  const zero = /^0*$/.test(int + frac);
+  const [prefix, suffix] = zero ? (negative ? spec.negativeZero : spec.zero) : negative ? spec.negative : spec.positive;
+  const shown =
+    groupDigits(int.padStart(Math.max(spec.minInt, 1), '0'), spec.grouping, spec.group) + (frac === '' ? '' : spec.decimal + frac);
+  const digits = spec.digits;
+  return prefix + (digits === undefined ? shown : shown.replace(/[0-9]/g, (d) => digits[Number(d)]!)) + suffix;
+}

package/src/tools/native/plurals.ts

@@ -0,0 +1,103 @@
+/**
+ * CLDR's plural rules, read into conditions a native target writes as code. Swift, the JVM and Rust
+ * have no plural rules of their own that every platform carries, so each generated file brings the
+ * rules of the locales it formats, from the same CLDR data `Intl.PluralRules` is built on.
+ */
+import ordinals from 'cldr-core/supplemental/ordinals.json' with { type: 'json' };
+import cardinals from 'cldr-core/supplemental/plurals.json' with { type: 'json' };
+
+/** CLDR's operands: `n` the absolute value, `i` its integer digits, `v`/`w` the count of fraction digits with and without trailing zeros, `f`/`t` those digits, `c`/`e` the compact exponent. */
+export type Operand = 'n' | 'i' | 'v' | 'w' | 'f' | 't' | 'c' | 'e';
+
+/** `i % 10 = 2..4, 7`: the operand, less its modulus, in (or with `negated`, not in) the ranges. A single value is a range of one. */
+export interface Relation {
+  operand: Operand;
+  mod?: number;
+  negated: boolean;
+  ranges: (readonly [number, number])[];
+}
+
+/** Relations joined by `and`, those joined by `or`. */
+export type Condition = Relation[][];
+
+/** A locale's categories in CLDR's order, each with its condition. `other` holds wherever none does, so it has none. */
+export type PluralRules = (readonly [category: string, Condition])[];
+
+export type Operands = Record<Operand, number>;
+
+type RuleData = Record<string, Record<string, string>>;
+
+const DATA = {
+  cardinal: cardinals.supplemental['plurals-type-cardinal'] as RuleData,
+  ordinal: ordinals.supplemental['plurals-type-ordinal'] as RuleData,
+};
+
+/**
+ * The rules for `locale`, found as `Intl.PluralRules` finds its locale, then by its parents
+ * (`pt-PT`, then `pt`), so the generated code picks the category the browser would.
+ */
+export function pluralRules(locale: string, type: 'cardinal' | 'ordinal'): PluralRules {
+  const data = DATA[type];
+  let tag = new Intl.PluralRules(locale, { type }).resolvedOptions().locale;
+  while (!(tag in data) && tag.includes('-')) tag = tag.slice(0, tag.lastIndexOf('-'));
+  const rules = data[tag] ?? data['root'] ?? {};
+  return Object.entries(rules).flatMap(([name, rule]) => {
+    const category = name.slice('pluralRule-count-'.length);
+    return category === 'other' ? [] : [[category, parseCondition(rule.split('@', 1)[0]!)] as const];
+  });
+}
+
+/** `v = 0 and i % 10 = 1 or n = 0..1`, its samples already cut. */
+export function parseCondition(source: string): Condition {
+  return source
+    .trim()
+    .split(/\s+or\s+/)
+    .map((and) => and.split(/\s+and\s+/).map(parseRelation));
+}
+
+function parseRelation(source: string): Relation {
+  const match = /^([nivwftce])\s*(?:%\s*(\d+))?\s*(!?=)\s*(.+)$/.exec(source.trim());
+  if (match === null) throw new Error(`prosebook: a CLDR plural rule it can't read: "${source}"`);
+  const [, operand, mod, op, list] = match;
+  return {
+    operand: operand as Operand,
+    ...(mod !== undefined && { mod: Number(mod) }),
+    negated: op === '!=',
+    ranges: list!.split(',').map((range) => {
+      const [from, to = from] = range.trim().split('..');
+      return [Number(from), Number(to)] as const;
+    }),
+  };
+}
+
+/** A range of one is an equality; a wider range holds integers only, as CLDR's `in` does. */
+export function inRange(value: number, [from, to]: readonly [number, number]): boolean {
+  return from === to ? value === from : Number.isInteger(value) && value >= from && value <= to;
+}
+
+function holds(relation: Relation, operands: Operands): boolean {
+  const raw = operands[relation.operand];
+  const value = relation.mod === undefined ? raw : raw % relation.mod;
+  return relation.ranges.some((range) => inRange(value, range)) !== relation.negated;
+}
+
+/** The category `rules` give, as the generated code picks it. */
+export function categoryOf(rules: PluralRules, operands: Operands): string {
+  for (const [category, condition] of rules) if (condition.some((and) => and.every((r) => holds(r, operands)))) return category;
+  return 'other';
+}
+
+/** The operands of a number written with `int` and `frac` digits, as CLDR reads them. */
+export function operandsOf(int: string, frac: string): Operands {
+  const trimmed = frac.replace(/0+$/, '');
+  return {
+    n: Number(`${int}.${frac || '0'}`),
+    i: Number(int),
+    v: frac.length,
+    w: trimmed.length,
+    f: Number(frac || '0'),
+    t: Number(trimmed || '0'),
+    c: 0,
+    e: 0,
+  };
+}

package/src/tools/native/rust.ts

@@ -0,0 +1,367 @@
+/**
+ * The model as a Rust module: an enum of locales with a method per message, and what formats them in
+ * a private `rt` module, so no argument a message names can shadow it.
+ */
+import type { NativeTarget } from '#src/tools/config.ts';
+import { checkNames, conditionCode, float, leading, pascal, snake, stringLiteral, wordsOf } from './emit.ts';
+import type { NativeMessage, NativeModel, Part } from './model.ts';
+import type { NumberSpec } from './number.ts';
+
+const KEYWORDS = 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 = (name: string) => (KEYWORDS.has(name) ? `${name}_` : name);
+const lit = (value: string) => stringLiteral(value, 'rust');
+const variant = (tag: string) => pascal(wordsOf(tag));
+const argName = (name: string) => ident(leading(snake(wordsOf(name))));
+
+function doc(lines: string[], indent: string): string {
+  return lines.map((l) => (l === '' ? `${indent}///\n` : `${indent}/// ${l}\n`)).join('');
+}
+
+/** The parts as an expression of type `String`. */
+function expr(parts: Part[], indent: string): string {
+  if (parts.length === 0) return 'String::new()';
+  const [only] = parts;
+  if (parts.length === 1 && only !== undefined) {
+    if (only.type === 'text') return `String::from(${lit(only.value)})`;
+    return only.type === 'string' ? `${argName(only.arg)}.to_string()` : value(only, indent);
+  }
+  let format = '';
+  const args: string[] = [];
+  for (const part of parts) {
+    if (part.type === 'text') {
+      format += part.value.replaceAll('{', '{{').replaceAll('}', '}}');
+      continue;
+    }
+    format += '{}';
+    args.push(value(part, indent));
+  }
+  return `format!(${[lit(format), ...args].join(', ')})`;
+}
+
+function value(part: Exclude<Part, { type: 'text' }>, indent: 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)},\n`).join('');
+    return `match ${argName(part.arg)} {\n${arms}${inner}_ => ${expr(part.other, inner)},\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);
+  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)}, ${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)},\n`)
+    .join('');
+  const pick = `rt::plural(${on}, ${float(part.offset)}, &[${exact}], rt::R${part.rules}, ${minFrac}, ${maxFrac})`;
+  return `match ${pick} {\n${arms}${inner}_ => ${expr(part.other, inner)},\n${indent}}`;
+}
+
+function method(m: NativeMessage, name: string, enumName: string): string {
+  const head = doc(m.doc, '    ');
+  const arms = (render: (parts: Part[]) => string) =>
+    m.bodies.map((b) => `            ${b.locales.map((l) => `${enumName}::${variant(l)}`).join(' | ')} => ${render(b.parts)},\n`).join('');
+  const isStatic = m.bodies.every((b) => b.parts.every((p) => p.type === 'text'));
+  if (isStatic && m.args.length === 0)
+    return `${head}    pub fn ${name}(self) -> &'static str {\n        match self {\n${arms((parts) => lit(parts[0]?.type === 'text' ? parts[0].value : ''))}        }\n    }\n`;
+  const params = m.args.map((a) => `, ${argName(a.name)}: ${a.type === 'number' ? 'impl Number' : '&str'}`).join('');
+  const argDocs = m.args.filter((a) => a.doc !== undefined).map((a) => `* \`${argName(a.name)}\`: ${a.doc}`);
+  const docs = argDocs.length > 0 ? `${head}    ///\n${doc(argDocs, '    ')}` : head;
+  const numbers = m.args
+    .filter((a) => a.type === 'number')
+    .map((a) => `        let ${argName(a.name)} = ${argName(a.name)}.as_f64();\n`)
+    .join('');
+  return `${docs}    pub fn ${name}(self${params}) -> String {\n${numbers}        match self {\n${arms((parts) => expr(parts, '            '))}        }\n    }\n`;
+}
+
+function formatConst(spec: NumberSpec, i: number): string {
+  const affix = ([prefix, suffix]: readonly [string, string]) => `(${lit(prefix)}, ${lit(suffix)})`;
+  const fields = [
+    `min_int: ${spec.minInt}`,
+    `min_frac: ${spec.minFrac}`,
+    `max_frac: ${spec.maxFrac}`,
+    `shift: ${spec.shift}`,
+    `primary: ${spec.grouping.primary}`,
+    `secondary: ${spec.grouping.secondary}`,
+    `min_group: ${spec.grouping.min}`,
+    `decimal: ${lit(spec.decimal)}`,
+    `group: ${lit(spec.group)}`,
+    `digits: ${spec.digits === undefined ? 'None' : `Some([${spec.digits.map(lit).join(', ')}])`}`,
+    `positive: ${affix(spec.positive)}`,
+    `negative: ${affix(spec.negative)}`,
+    `zero: ${affix(spec.zero)}`,
+    `negative_zero: ${affix(spec.negativeZero)}`,
+    `infinity: ${lit(spec.infinity)}`,
+    `negative_infinity: ${lit(spec.negativeInfinity)}`,
+  ];
+  return `    pub const F${i}: Format = Format {\n${fields.map((f) => `        ${f},\n`).join('')}    };\n`;
+}
+
+const NUMBER = `
+    /// A number format, taken apart when the file was generated.
+    pub struct Format {
+        pub min_int: usize,
+        pub min_frac: usize,
+        pub max_frac: usize,
+        pub shift: usize,
+        pub primary: usize,
+        pub secondary: usize,
+        pub min_group: usize,
+        pub decimal: &'static str,
+        pub group: &'static str,
+        pub digits: Option<[&'static str; 10]>,
+        pub positive: (&'static str, &'static str),
+        pub negative: (&'static str, &'static str),
+        pub zero: (&'static str, &'static str),
+        pub negative_zero: (&'static str, &'static str),
+        pub infinity: &'static str,
+        pub negative_infinity: &'static str,
+    }
+
+    /// \`value\` as \`format\` writes it, or \`fallback\` where it isn't a number.
+    pub fn number(value: f64, format: &Format, fallback: &str) -> String {
+        if value.is_nan() {
+            return fallback.to_string();
+        }
+        if value.is_infinite() {
+            return (if value > 0.0 { format.infinity } else { format.negative_infinity }).to_string();
+        }
+        let (mut int, frac) = digits(value.abs(), format.shift, format.min_frac, format.max_frac);
+        let zero = int.bytes().chain(frac.bytes()).all(|b| b == b'0');
+        let (prefix, suffix) = match (zero, value.is_sign_negative()) {
+            (true, true) => format.negative_zero,
+            (true, false) => format.zero,
+            (false, true) => format.negative,
+            (false, false) => format.positive,
+        };
+        while int.len() < format.min_int.max(1) {
+            int.insert(0, '0');
+        }
+        let grouped = format.min_group > 0 && int.len() >= format.primary + format.min_group;
+        let mut out = String::from(prefix);
+        for (i, digit) in int.bytes().enumerate() {
+            let left = int.len() - i;
+            if grouped && i > 0 && (left == format.primary || (left > format.primary && (left - format.primary) % format.secondary == 0)) {
+                out.push_str(format.group);
+            }
+            push_digit(&mut out, digit, format);
+        }
+        if !frac.is_empty() {
+            out.push_str(format.decimal);
+            for digit in frac.bytes() {
+                push_digit(&mut out, digit, format);
+            }
+        }
+        out.push_str(suffix);
+        out
+    }
+
+    fn push_digit(out: &mut String, digit: u8, format: &Format) {
+        match format.digits {
+            Some(digits) => out.push_str(digits[(digit - b'0') as usize]),
+            None => out.push(digit as char),
+        }
+    }
+
+    /// 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\`.
+    pub fn digits(value: f64, shift: usize, min: usize, max: usize) -> (String, String) {
+        // Display writes the shortest digits that read back, and never an exponent.
+        let shortest = value.to_string();
+        let (int, frac) = shortest.split_once('.').unwrap_or((&shortest, ""));
+        let mut all: Vec<u8> = int.bytes().map(|b| b - b'0').collect();
+        let mut rest = frac.bytes().map(|b| b - b'0');
+        let mut point = all.len() + shift;
+        for _ in 0..shift + max {
+            all.push(rest.next().unwrap_or(0));
+        }
+        if rest.next().unwrap_or(0) >= 5 {
+            let mut at = all.len();
+            loop {
+                if at == 0 {
+                    all.insert(0, 1);
+                    point += 1;
+                    break;
+                }
+                at -= 1;
+                if all[at] == 9 {
+                    all[at] = 0;
+                } else {
+                    all[at] += 1;
+                    break;
+                }
+            }
+        }
+        let mut frac = all.split_off(point);
+        while frac.len() > min && frac.last() == Some(&0) {
+            frac.pop();
+        }
+        let first = all.iter().position(|&d| d != 0).unwrap_or(all.len());
+        let text = |d: &[u8]| d.iter().map(|&d| (b'0' + d) as char).collect::<String>();
+        (text(&all[first..]), text(&frac))
+    }
+`;
+
+const PLURAL = `
+    /// CLDR's plural operands of a number as written.
+    pub struct Operands {
+        pub n: f64,
+        pub i: f64,
+        pub v: f64,
+        pub w: f64,
+        pub f: f64,
+        pub t: f64,
+        pub c: f64,
+        pub e: f64,
+    }
+
+    /// The arm a plural takes: the \`=N\` that \`value\` equals, else the category of \`value\` less \`offset\`.
+    pub fn plural(
+        value: f64,
+        offset: f64,
+        exact: &[(f64, &'static str)],
+        rules: fn(&Operands) -> &'static str,
+        min: usize,
+        max: usize,
+    ) -> &'static str {
+        match exact.iter().find(|(n, _)| *n == value) {
+            Some(&(_, arm)) => arm,
+            None => category(rules, value - offset, min, max),
+        }
+    }
+
+    /// The category \`rules\` give \`value\`, rounded to between \`min\` and \`max\` fraction digits.
+    fn category(rules: fn(&Operands) -> &'static str, value: f64, min: usize, max: usize) -> &'static str {
+        if !value.is_finite() {
+            return "other";
+        }
+        let (int, frac) = digits(value.abs(), 0, min, max);
+        let int = if int.is_empty() { String::from("0") } else { int };
+        let trimmed = frac.trim_end_matches('0');
+        let read = |s: &str| if s.is_empty() { 0.0 } else { s.parse().unwrap_or(0.0) };
+        rules(&Operands {
+            n: if frac.is_empty() { read(&int) } else { read(&format!("{}.{}", int, frac)) },
+            i: read(&int),
+            v: frac.len() as f64,
+            w: trimmed.len() as f64,
+            f: read(&frac),
+            t: read(trimmed),
+            c: 0.0,
+            e: 0.0,
+        })
+    }
+
+    /// An integer in the range, as CLDR's ranges hold.
+    fn within(value: f64, from: f64, to: f64) -> bool {
+        value.fract() == 0.0 && value >= from && value <= to
+    }
+
+    /// \`Math.round\`: half up, toward positive infinity.
+    pub fn round(value: f64) -> f64 {
+        let floor = value.floor();
+        if value - floor >= 0.5 { floor + 1.0 } else { floor }
+    }
+`;
+
+const NUMBER_TRAIT = `
+/// A number a message formats: any of Rust's integers or floats.
+pub trait Number: Copy {
+    fn as_f64(self) -> f64;
+}
+
+macro_rules! number {
+    ($($t:ty),*) => {$(
+        impl Number for $t {
+            fn as_f64(self) -> f64 {
+                self as f64
+            }
+        }
+    )*};
+}
+
+number!(i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64);
+`;
+
+export function rustModule(model: NativeModel, target: NativeTarget & { name: string }, banner: string): string {
+  const name = target.name;
+  const names = model.messages.map((m): [string, string] => [m.key, ident(leading(snake(m.words)))]);
+  checkNames('rust', names, ['tag', 'negotiate']);
+  const variants = model.locales.map((l) => `    /// \`${l}\`${l === model.source ? ', the source' : ''}.\n    ${variant(l)},\n`).join('');
+  const tags = model.locales.map((l) => `            ${name}::${variant(l)} => ${lit(l)},\n`).join('');
+  const methods = model.messages.map((m, i) => method(m, names[i]![1], name)).join('\n');
+  const usesNumbers = model.messages.some((m) => m.args.some((a) => a.type === 'number'));
+  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})` })} {\n            return ${lit(category)};\n        }\n`,
+      );
+      return `    /// ${rule}\n    pub fn R${i}(${rules.length > 0 ? 'o' : '_o'}: &Operands) -> &'static str {\n${checks.join('')}        "other"\n    }\n`;
+    })
+    .join('\n');
+  const runtime =
+    model.formats.length + model.rules.length === 0
+      ? ''
+      : `
+/// What formats the messages, generated with them.
+mod rt {${NUMBER}${model.rules.length > 0 ? PLURAL : ''}
+${model.formats.map(formatConst).join('\n')}${rules === '' ? '' : `\n${rules}`}}
+`;
+
+  return `${banner}
+#![allow(dead_code, non_snake_case, clippy::all)]
+${usesNumbers ? NUMBER_TRAIT : ''}
+/// A locale the catalog is written or translated in, and its messages.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum ${name} {
+${variants}}
+
+impl ${name} {
+    /// Every locale, the source first.
+    pub const ALL: [${name}; ${model.locales.length}] = [${model.locales.map((l) => `${name}::${variant(l)}`).join(', ')}];
+
+    /// The locale the catalog is written in, which every message falls back to.
+    pub const SOURCE: ${name} = ${name}::${variant(model.source)};
+
+    /// The locale's BCP 47 tag.
+    pub fn tag(self) -> &'static str {
+        match self {
+${tags}        }
+    }
+
+    /// 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.
+    pub fn negotiate<S: AsRef<str>>(requested: &[S]) -> ${name} {
+        let language = |tag: &str| tag.split('-').next().unwrap_or("").to_ascii_lowercase();
+        for want in requested {
+            let want = want.as_ref();
+            let mut tag = want;
+            loop {
+                if let Some(found) = Self::ALL.iter().find(|l| l.tag().eq_ignore_ascii_case(tag)) {
+                    return *found;
+                }
+                match tag.rfind('-') {
+                    Some(cut) => tag = &tag[..cut],
+                    None => break,
+                }
+            }
+            if let Some(found) = Self::ALL.iter().find(|l| language(l.tag()) == language(want)) {
+                return *found;
+            }
+        }
+        Self::SOURCE
+    }
+
+${methods}}
+${runtime}`;
+}