prosebook 0.2.0 → 0.3.0

package/src/tools/mf2.ts

@@ -5,8 +5,10 @@
  *
  * The tree holds what a message does, not how it was written. `.input {$n :number}` becomes a number
  * element at each `{$n}`, and `.match` becomes plural and select elements, one level per selector,
- * built so the runtime's ICU-style selection picks the variant MF2's would (see `matchTree`). Option
- * values are literals, resolved here into `Intl` options, so the runtime is the same for both.
+ * built so the runtime's ICU-style selection picks the variant MF2's would (see `matchTree`). Literal
+ * option values are resolved here into `Intl` options, so the runtime is the same for both. An option
+ * an argument gives (`currency=$code`, of those in `FROM_ARGUMENT`) rides on the style as the `Intl`
+ * option it sets, which the compiled message passes beside the hoisted ones.
  */
 import { SKELETON_TYPE, TYPE } from '@formatjs/icu-messageformat-parser';
 import type {
@@ -21,7 +23,7 @@ import type {
 } from '@formatjs/icu-messageformat-parser';
 import { MessageSyntaxError, parseMessage, stringifyMessage, validate, type Model } from 'messageformat';
 
-import { walk, type MessageFormatElement } from './icu.ts';
+import { selectionOf, walk, type MessageFormatElement, type OptionArgs, type Placeholder, type Selection } from './icu.ts';
 
 type Element = MessageFormatElement;
 
@@ -29,6 +31,10 @@ type Element = MessageFormatElement;
 export interface Mf2Function {
   name: string;
   options: Record<string, string>;
+  /** Options given by an argument, as `currency=$code`: the option's name to the argument's. */
+  args?: Record<string, string>;
+  /** `u:dir`: the direction the value is written in, which picks the mark isolating it. */
+  dir?: 'ltr' | 'rtl' | 'auto';
 }
 
 type Value = { kind: 'literal'; value: string; fn?: Mf2Function } | { kind: 'variable'; name: string; fn?: Mf2Function; offset: number };
@@ -39,8 +45,23 @@ interface Selector {
   name: string;
   kind: 'plural' | 'ordinal' | 'exact' | 'string';
   offset: number;
+  /** For a number selected on other than as a bare `:number`. */
+  selection?: Selection;
 }
 
+/** The `Intl.NumberFormat` options `Intl.PluralRules` takes too, which change a number's category. */
+const PLURAL_OPTIONS = new Set([
+  'minimumIntegerDigits',
+  'minimumFractionDigits',
+  'maximumFractionDigits',
+  'minimumSignificantDigits',
+  'maximumSignificantDigits',
+  'roundingIncrement',
+  'roundingMode',
+  'roundingPriority',
+  'trailingZeroDisplay',
+]);
+
 export const NUMBER_LITERAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][-+]?\d+)?$/;
 const CATEGORIES = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
 const NAME = /^[\p{L}_][\p{L}\p{N}_.-]*$/u;
@@ -96,6 +117,26 @@ const ENUMS: Record<string, readonly string[]> = {
   hour12: ['true', 'false'],
 };
 
+const oneOf = (values: readonly string[]) => values.map((v) => JSON.stringify(v)).join(' | ');
+
+/**
+ * Options an argument may give, with the `Intl` options each sets and the argument's type. These pass
+ * to `Intl` as they are, so the runtime merges them in; the rest change what the formatter is (a
+ * date's fields, how a number selects) and are settled when the message compiles.
+ */
+const FROM_ARGUMENT: Record<string, { intl: readonly string[]; type: string }> = {
+  currency: { intl: ['currency'], type: 'string' },
+  currencyDisplay: { intl: ['currencyDisplay'], type: oneOf(ENUMS.currencyDisplay!) },
+  currencySign: { intl: ['currencySign'], type: oneOf(['standard', 'accounting']) },
+  unit: { intl: ['unit'], type: 'string' },
+  unitDisplay: { intl: ['unitDisplay'], type: oneOf(['long', 'short', 'narrow']) },
+  signDisplay: { intl: ['signDisplay'], type: oneOf(['auto', 'always', 'exceptZero', 'negative', 'never']) },
+  fractionDigits: { intl: ['minimumFractionDigits', 'maximumFractionDigits'], type: 'number' },
+  ...Object.fromEntries(DIGITS.filter((d) => d !== 'roundingIncrement').map((d) => [d, { intl: [d], type: 'number' }])),
+  timeZone: { intl: ['timeZone'], type: 'string' },
+  calendar: { intl: ['calendar'], type: 'string' },
+};
+
 /** Options an operand's function doesn't pass on to these, per the spec. */
 const DISCARDED: Record<string, readonly string[]> = {
   integer: ['minimumFractionDigits', 'maximumFractionDigits', 'minimumSignificantDigits'],
@@ -144,7 +185,8 @@ function syntaxProblem(text: string, e: unknown): string {
 }
 
 /** An MF2 message as the element tree. Throws, with the fix, where it can't be read or compiled. */
-export function parseMf2(text: string, locale: string): Element[] {
+export function parseMf2(text: string, locale: string, isolate: Isolate = 'rtl'): Element[] {
+  const reading: Reading = { locale, isolate, dir: directionOf(locale) };
   let message: Model.Message;
   try {
     message = parseMessage(text);
@@ -156,42 +198,93 @@ export function parseMf2(text: string, locale: string): Element[] {
   }
   const scope: Scope = new Map();
   for (const declaration of message.declarations)
-    // `.input` reads the argument itself; a `.local` can build on what is declared before it.
-    scope.set(declaration.name, resolve(declaration.value, declaration.type === 'input' ? new Map() : scope));
+    // `.input` reads the argument itself; a `.local` can build on what is declared before it. The
+    // options of either can name what is declared before them.
+    scope.set(declaration.name, resolve(declaration.value, declaration.type === 'input' ? new Map() : scope, scope));
 
-  if (message.type === 'message') return pattern(message.pattern, scope, locale);
+  if (message.type === 'message') return pattern(message.pattern, scope, reading);
   const selectors = message.selectors.map((s) => selectorOf(s.name, scope));
   const candidates = message.variants.map((variant) => {
     const keys = variant.keys.map((k) => (k.type === '*' ? null : k.value));
     keys.forEach((key, i) => checkKey(selectors[i]!, key, message.selectors[i]!.name));
-    return { keys, prefs: [], value: pattern(variant.value, scope, locale) };
+    return { keys, prefs: [], value: pattern(variant.value, scope, reading) };
   });
   return matchTree(selectors, candidates, 0, locale);
 }
 
-function functionOf(ref: Model.FunctionRef): Mf2Function {
+/**
+ * When a placeholder is isolated from the text around it, so a value written the other way can't
+ * reorder it: `'rtl'` in a locale not known to run left to right, or where `u:dir` asks; `'always'`
+ * also for every value of unknown direction (a string), as the spec's default strategy has it.
+ */
+export type Isolate = 'rtl' | 'always' | false;
+
+type Direction = 'ltr' | 'rtl' | 'auto';
+
+interface Reading {
+  locale: string;
+  isolate: Isolate;
+  /** The locale's direction, which the message's is. */
+  dir: Direction;
+}
+
+// The scripts CLDR writes right to left, as the `messageformat` package lists them.
+const RTL_SCRIPTS = new Set(['Adlm', 'Arab', 'Hebr', 'Mand', 'Nkoo', 'Rohg', 'Syrc', 'Thaa']);
+const [LRI, RLI, FSI, PDI] = ['\u2066', '\u2067', '\u2068', '\u2069'];
+
+function directionOf(locale: string): Direction {
+  try {
+    const script = new Intl.Locale(locale).maximize().script;
+    return script === undefined ? 'auto' : RTL_SCRIPTS.has(script) ? 'rtl' : 'ltr';
+  } catch {
+    return 'auto';
+  }
+}
+
+/** The fallback a placeholder shows, and the marks isolating it where `isolate` and `u:dir` ask. */
+function placeholderFor(name: string, fn: Mf2Function | undefined, r: Reading): Placeholder {
+  const fallback = `{$${name}}`;
+  if (r.isolate === false) return { fallback };
+  // A number or date is written as the locale writes; a string's direction is its own.
+  const dir = fn?.dir ?? (fn === undefined || fn.name === 'string' ? 'auto' : r.dir);
+  const isolate = r.dir !== 'ltr' || (dir !== 'ltr' && (r.isolate === 'always' || fn?.dir !== undefined));
+  if (!isolate) return { fallback };
+  return { fallback, isolate: [dir === 'ltr' ? LRI : dir === 'rtl' ? RLI : FSI, PDI] };
+}
+
+function functionOf(ref: Model.FunctionRef, scope: Scope): Mf2Function {
   const allowed = OPTIONS[ref.name];
   if (allowed === undefined) {
     const known = Object.keys(OPTIONS).map((n) => `:${n}`);
     throw new Error(`:${ref.name} is not a function prosebook knows: ${known.join(', ')}`);
   }
   const options: Record<string, string> = {};
+  const args: Record<string, string> = {};
+  let dir: Mf2Function['dir'];
   for (const [key, value] of Object.entries(ref.options ?? {})) {
-    // `u:id` and `u:dir` say nothing about formatting here: there is no bidi isolation to steer.
-    if (key === 'u:id' || key === 'u:dir') continue;
-    if (value.type === 'variable')
-      throw new Error(`:${ref.name} ${key}=$${value.name}: option values are literals here, since formatting is fixed at build time`);
+    // `u:id` names a part of the formatted output, which this runtime doesn't hand out.
+    if (key === 'u:id') continue;
+    if (key === 'u:dir') {
+      const dirs = ['ltr', 'rtl', 'auto', 'inherit'];
+      if (value.type !== 'literal' || !dirs.includes(value.value))
+        throw new Error(`:${ref.name} u:dir is one of ${dirs.join(', ')}, written in the message`);
+      // `inherit` is the direction it would have had anyway.
+      if (value.value !== 'inherit') dir = value.value as Mf2Function['dir'];
+      continue;
+    }
     if (!allowed.includes(key))
       throw new Error(`:${ref.name} has no option "${key}"${allowed.length > 0 ? `: ${allowed.join(', ')}` : ''}`);
+    const literal = value.type === 'literal' ? value.value : optionArg(ref.name, key, value.name, scope);
+    if (typeof literal !== 'string') {
+      args[key] = literal.arg;
+      continue;
+    }
     const values = ENUMS[key];
-    if (values !== undefined && !values.includes(value.value))
-      throw new Error(`:${ref.name} ${key}=${value.value} is not a value it takes: ${values.join(', ')}`);
-    if (DIGITS.includes(key) && !/^\d+$/.test(value.value)) throw new Error(`:${ref.name} ${key}=${value.value} is not a whole number`);
-    options[key] = value.value;
-  }
-  if (ref.name === 'currency' && options.currency === undefined)
-    throw new Error(':currency needs its currency named: {$price :currency currency=EUR}');
-  if (ref.name === 'unit' && options.unit === undefined) throw new Error(':unit needs its unit named: {$distance :unit unit=kilometer}');
+    if (values !== undefined && !values.includes(literal))
+      throw new Error(`:${ref.name} ${key}=${literal} is not a value it takes: ${values.join(', ')}`);
+    if (DIGITS.includes(key) && !/^\d+$/.test(literal)) throw new Error(`:${ref.name} ${key}=${literal} is not a whole number`);
+    options[key] = literal;
+  }
   if (ref.name === 'unit' && ref.options?.usage !== undefined)
     throw new Error(":unit usage converts between units, which `Intl` can't do: convert the value before passing it");
   if (options.timeZone === 'input') throw new Error(`:${ref.name} timeZone=input needs a zoned value, which a JavaScript Date isn't`);
@@ -200,14 +293,48 @@ function functionOf(ref: Model.FunctionRef): Mf2Function {
     if (given.length !== 1 || !/^\d+$/.test(options[given[0]!]!))
       throw new Error(':offset takes one of add or subtract, as a whole number: {$count :offset subtract=1}');
   }
-  return { name: ref.name, options };
+  return { name: ref.name, options, ...(Object.keys(args).length > 0 && { args }), ...(dir && { dir }) };
 }
 
-function resolve(expr: Model.Expression, scope: Scope): Value {
-  const fn = expr.functionRef === undefined ? undefined : functionOf(expr.functionRef);
+/**
+ * The argument an option names, or the literal a `.local` it names holds. A variable declared with a
+ * function of its own is refused: what it would give the option is its formatted text.
+ */
+function optionArg(fn: string, key: string, name: string, scope: Scope): string | { arg: string } {
+  const bound = scope.get(name);
+  const plain = bound?.fn === undefined || bound.fn.name === 'string';
+  if (bound?.kind === 'literal' && plain) return bound.value;
+  if (FROM_ARGUMENT[key] === undefined) {
+    const which = Object.keys(FROM_ARGUMENT).filter((k) => OPTIONS[fn]!.includes(k));
+    const can = which.length > 0 ? `: of :${fn}'s, only ${which.join(', ')} can` : '';
+    throw new Error(`:${fn} ${key}=$${name}: ${key} is settled as the message compiles, so write its value in the message${can}`);
+  }
+  if (bound === undefined) return { arg: name };
+  if (bound.kind === 'variable' && plain && bound.offset === 0) return { arg: bound.name };
+  throw new Error(`:${fn} ${key}=$${name}: $${name} is formatted, so it can't give an option: name the argument itself`);
+}
+
+function resolve(expr: Model.Expression, scope: Scope, optionScope = scope): Value {
+  const fn = expr.functionRef === undefined ? undefined : functionOf(expr.functionRef, optionScope);
   if (expr.arg === undefined) throw new Error(`{:${fn!.name}} has nothing to format: give it a value, {$value :${fn!.name}}`);
-  if (expr.arg.type === 'literal') return apply({ kind: 'literal', value: expr.arg.value }, fn);
-  return apply(scope.get(expr.arg.name) ?? { kind: 'variable', name: expr.arg.name, offset: 0 }, fn);
+  const base: Value =
+    expr.arg.type === 'literal'
+      ? { kind: 'literal', value: expr.arg.value }
+      : (scope.get(expr.arg.name) ?? { kind: 'variable', name: expr.arg.name, offset: 0 });
+  const value = apply(base, fn);
+  if (value.fn !== undefined) checkNamed(value.fn);
+  return value;
+}
+
+/**
+ * A currency or a unit named, on the function or on the one its operand was declared with: after
+ * `.input {$price :currency currency=EUR}`, `{$price :currency fractionDigits=0}` is still in euros.
+ */
+function checkNamed(fn: Mf2Function): void {
+  const given = (key: string) => fn.options[key] !== undefined || fn.args?.[key] !== undefined;
+  if (fn.name === 'currency' && !given('currency'))
+    throw new Error(':currency needs its currency named: {$price :currency currency=EUR}, or currency=$code to take it from an argument');
+  if (fn.name === 'unit' && !given('unit')) throw new Error(':unit needs its unit named: {$distance :unit unit=kilometer}');
 }
 
 /** `fn` applied to a value that may already carry one: options carry over within a family, as the spec has it. */
@@ -221,8 +348,17 @@ function apply(base: Value, fn: Mf2Function | undefined): Value {
   }
   if (base.fn === undefined || family(base.fn.name) !== family(fn.name)) return { ...base, fn };
   const inherited = { ...base.fn.options };
-  for (const key of DISCARDED[fn.name] ?? []) delete inherited[key];
-  return { ...base, fn: { name: fn.name, options: { ...inherited, ...fn.options } } };
+  const inheritedArgs = { ...base.fn.args };
+  for (const key of DISCARDED[fn.name] ?? []) {
+    delete inherited[key];
+    delete inheritedArgs[key];
+  }
+  // An option given again replaces the one inherited, whether either is a literal or an argument.
+  for (const key of Object.keys(fn.options)) delete inheritedArgs[key];
+  for (const key of Object.keys(fn.args ?? {})) delete inherited[key];
+  const args = { ...inheritedArgs, ...fn.args };
+  const options = { ...inherited, ...fn.options };
+  return { ...base, fn: { name: fn.name, options, ...(Object.keys(args).length > 0 && { args }), ...(fn.dir && { dir: fn.dir }) } };
 }
 
 function literalNumber(value: string): string {
@@ -238,11 +374,27 @@ function selectorOf(name: string, scope: Scope): Selector {
     throw new Error(`.match $${name} selects on a literal, which always picks the same variant: use that variant's text`);
   const { fn } = value;
   if (fn.name === 'string') return { name: value.name, kind: 'string', offset: 0 };
-  if (fn.name === 'number' || fn.name === 'integer') {
+  if (fn.name === 'number' || fn.name === 'integer' || fn.name === 'percent') {
     const kind = (fn.options.select ?? 'plural') as Selector['kind'];
-    return { name: value.name, kind, offset: value.offset };
+    return { name: value.name, kind, offset: value.offset, ...selectionWith(fn) };
   }
-  throw new Error(`.match $${name} selects with :${fn.name}, which prosebook can't select on: use :number, :integer or :string`);
+  throw new Error(`.match $${name} selects with :${fn.name}, which prosebook can't select on: use :number, :integer, :percent or :string`);
+}
+
+/**
+ * What a number is selected with beyond its kind, as the spec has it: its category as formatted
+ * (`1.0` is `other` in English), `:integer` on the value rounded, `:percent` on it times 100. None
+ * for a bare `:number`, which selects as MF1 does.
+ */
+function selectionWith(fn: Mf2Function): { selection?: Selection } {
+  const pick = <T>(from: Record<string, T>) => Object.fromEntries(Object.entries(from).filter(([k]) => PLURAL_OPTIONS.has(k)));
+  const options = pick(intlNumber(fn) as Record<string, unknown>) as Intl.PluralRulesOptions;
+  const args = pick(optionArgs(fn).args ?? {});
+  const value = fn.name === 'integer' ? 'round' : fn.name === 'percent' ? 'percent' : undefined;
+  const plain = Object.keys(options).length === 0 && Object.keys(args).length === 0 && value === undefined;
+  // `select=exact` is kept too, so it is written back.
+  if (plain && fn.options.select !== 'exact') return {};
+  return { selection: { fn, options, ...(Object.keys(args).length > 0 && { args }), ...(value && { value }) } };
 }
 
 function checkKey(selector: Selector, key: string | null, name: string): void {
@@ -295,7 +447,7 @@ function matchTree(selectors: Selector[], candidates: Candidate[], i: number, lo
     arm('other', (key) => (key === null ? 1 : undefined));
     return [{ type: TYPE.select, value: s.name, options }];
   }
-  const rules = new Intl.PluralRules(locale, { type: s.kind === 'ordinal' ? 'ordinal' : 'cardinal' });
+  const rules = new Intl.PluralRules(locale, { ...s.selection?.options, type: s.kind === 'ordinal' ? 'ordinal' : 'cardinal' });
   for (const k of keys.filter((key) => NUMBER_LITERAL.test(key))) {
     const category = s.kind === 'exact' ? undefined : rules.select(Number(k));
     // The runtime compares the value before its offset; the key is the value after it.
@@ -308,7 +460,8 @@ function matchTree(selectors: Selector[], candidates: Candidate[], i: number, lo
     for (const c of categories) arm(c, (key) => (key === c ? 1 : key === null ? 2 : undefined));
   }
   if (!('other' in options)) arm('other', (key) => (key === null ? 2 : undefined));
-  return [{ type: TYPE.plural, value: s.name, offset: s.offset, pluralType: s.kind === 'ordinal' ? 'ordinal' : 'cardinal', options }];
+  const pluralType = s.kind === 'ordinal' ? 'ordinal' : 'cardinal';
+  return [{ type: TYPE.plural, value: s.name, offset: s.offset, pluralType, options, ...(s.selection && { selection: s.selection }) }];
 }
 
 function compare(a: number[], b: number[]): number {
@@ -316,7 +469,7 @@ function compare(a: number[], b: number[]): number {
   return 0;
 }
 
-function pattern(parts: Model.Pattern, scope: Scope, locale: string): Element[] {
+function pattern(parts: Model.Pattern, scope: Scope, r: Reading): Element[] {
   const root: Element[] = [];
   const open: { name: string; children: Element[] }[] = [];
   const push = (el: Element) => {
@@ -329,7 +482,7 @@ function pattern(parts: Model.Pattern, scope: Scope, locale: string): Element[]
     if (typeof part === 'string') {
       push({ type: TYPE.literal, value: part });
     } else if (part.type === 'expression') {
-      push(element(resolve(part, scope), locale));
+      push(element(resolve(part, scope), r));
     } else if (part.kind === 'close') {
       const top = open.pop();
       if (top?.name !== part.name) {
@@ -352,36 +505,55 @@ function pattern(parts: Model.Pattern, scope: Scope, locale: string): Element[]
   return root;
 }
 
-function element(value: Value, locale: string): Element {
-  if (value.kind === 'literal') return { type: TYPE.literal, value: formatLiteral(value, locale) };
+function element(value: Value, r: Reading): Element {
+  if (value.kind === 'literal') return { type: TYPE.literal, value: formatLiteral(value, r.locale) };
   const { name, fn, offset } = value;
+  const placeholder = placeholderFor(name, fn, r);
   // A value less its offset is what `#` prints inside a plural, so a plural with only `other` prints it.
-  if (offset !== 0)
-    return { type: TYPE.plural, value: name, offset, pluralType: 'cardinal', options: { other: { value: [{ type: TYPE.pound }] } } };
-  if (fn === undefined || fn.name === 'string') return { type: TYPE.argument, value: name };
-  if (NUMERIC.has(fn.name)) return { type: TYPE.number, value: name, style: numberStyle(fn) };
-  return { type: TYPE.date, value: name, style: dateStyle(fn) };
+  if (offset !== 0) {
+    const pound = { type: TYPE.pound, placeholder } as Element;
+    return { type: TYPE.plural, value: name, offset, pluralType: 'cardinal', options: { other: { value: [pound] } } };
+  }
+  if (fn === undefined || fn.name === 'string')
+    return { type: TYPE.argument, value: name, placeholder, ...(fn?.dir && { dir: fn.dir }) } as Element;
+  if (NUMERIC.has(fn.name)) return { type: TYPE.number, value: name, style: numberStyle(fn), placeholder } as Element;
+  return { type: TYPE.date, value: name, style: dateStyle(fn), placeholder } as Element;
 }
 
 /** A literal with a function is the same in every render, so it is formatted now. */
 function formatLiteral(value: Extract<Value, { kind: 'literal' }>, locale: string): string {
   const { fn } = value;
   if (fn === undefined || fn.name === 'string') return value.value;
+  const [option, arg] = Object.entries(fn.args ?? {})[0] ?? [];
+  if (option !== undefined) {
+    const why = 'a literal is formatted as the message compiles, so its options are literals too';
+    throw new Error(`|${value.value}| :${fn.name} ${option}=$${arg}: ${why}`);
+  }
   if (NUMERIC.has(fn.name)) return new Intl.NumberFormat(locale, intlNumber(fn)).format(Number(literalNumber(value.value)));
   const date = new Date(value.value);
   if (Number.isNaN(date.getTime())) throw new Error(`|${value.value}| is not a date: write it as an ISO 8601 date, like 2026-01-05`);
   return new Intl.DateTimeFormat(locale, intlDate(fn)).format(date);
 }
 
-export type Mf2NumberSkeleton = NumberSkeleton & { mf2: Mf2Function };
-export type Mf2DateSkeleton = DateTimeSkeleton & { mf2: Mf2Function };
+export type Mf2NumberSkeleton = NumberSkeleton & { mf2: Mf2Function; args?: OptionArgs };
+export type Mf2DateSkeleton = DateTimeSkeleton & { mf2: Mf2Function; args?: OptionArgs };
 
 function numberStyle(fn: Mf2Function): Mf2NumberSkeleton {
-  return { type: SKELETON_TYPE.number, tokens: [], parsedOptions: intlNumber(fn) as NumberSkeleton['parsedOptions'], mf2: fn };
+  const parsedOptions = intlNumber(fn) as NumberSkeleton['parsedOptions'];
+  return { type: SKELETON_TYPE.number, tokens: [], parsedOptions, mf2: fn, ...optionArgs(fn) };
 }
 
 function dateStyle(fn: Mf2Function): Mf2DateSkeleton {
-  return { type: SKELETON_TYPE.dateTime, pattern: '', parsedOptions: intlDate(fn), mf2: fn };
+  return { type: SKELETON_TYPE.dateTime, pattern: '', parsedOptions: intlDate(fn), mf2: fn, ...optionArgs(fn) };
+}
+
+/** The function's options given by arguments, as the `Intl` options the runtime merges in. */
+function optionArgs(fn: Mf2Function): { args?: OptionArgs } {
+  if (fn.args === undefined) return {};
+  const args: OptionArgs = {};
+  for (const [key, arg] of Object.entries(fn.args))
+    for (const intl of FROM_ARGUMENT[key]!.intl) args[intl] = { arg, type: FROM_ARGUMENT[key]!.type };
+  return { args };
 }
 
 /** The `Intl.NumberFormat` options a numeric function formats with. */
@@ -445,6 +617,8 @@ interface Found {
   offset: number;
   /** MF2 keys, in order of appearance; `*` is implied. */
   keys: string[];
+  /** The function it was selected with, read from MF2; a bare `:number` where none is kept. */
+  fn?: Mf2Function;
 }
 
 /** A message tree as MF2 text. Throws, saying what has no MF2 equivalent, where it can't be written. */
@@ -458,7 +632,11 @@ export function toMf2(ast: Element[], locale: string): string {
   const declarations: Model.Declaration[] = [];
   for (const s of found) {
     const fn: Model.FunctionRef =
-      s.kind === 'string' ? functionRef('string') : functionRef('number', s.kind === 'ordinal' ? { select: 'ordinal' } : {});
+      s.kind === 'string'
+        ? functionRef('string')
+        : s.fn !== undefined
+          ? written(s.fn)
+          : functionRef('number', s.kind === 'ordinal' ? { select: 'ordinal' } : {});
     declarations.push({ type: 'input', name: s.arg, value: { type: 'expression', arg: variable(s.arg), functionRef: fn } });
     if (s.offset !== 0) {
       declarations.push({
@@ -473,7 +651,8 @@ export function toMf2(ast: Element[], locale: string): string {
   let combos: (string | null)[][] = [[]];
   for (const s of found) combos = combos.flatMap((c) => [...s.keys, null].map((k) => [...c, k]));
   const variables = new Map(found.map((s) => [s.arg, s.variable]));
-  const numeric = new Set(found.filter((s) => s.kind !== 'string').map((s) => s.arg));
+  // Under a selector declared with more than a bare `:number`, a placeholder spells out its own.
+  const numeric = new Set(found.filter((s) => s.kind !== 'string' && s.fn === undefined).map((s) => s.arg));
   const render = (keys: (string | null)[]) =>
     toPattern(ast, { choice: new Map(found.map((s, i) => [s.arg, keys[i]!])), variables, numeric, locale });
   const variants = combos.map((keys) => ({ keys, pattern: render(keys), text: '' }));
@@ -506,7 +685,8 @@ function selectorsOf(ast: Element[]): Found[] {
       checkName(el.value);
       let local = `${el.value}_minus_${offset}`;
       while (names.has(local)) local += '_';
-      s = { arg: el.value, variable: offset === 0 ? el.value : local, kind, offset, keys: [] };
+      const fn = selectionOf(el)?.fn;
+      s = { arg: el.value, variable: offset === 0 ? el.value : local, kind, offset, keys: [], ...(fn && { fn }) };
       found.set(el.value, s);
     } else if (s.kind !== kind || s.offset !== offset) {
       throw new Error(
@@ -578,10 +758,16 @@ function toPattern(elements: Element[], w: Writing, pound?: string): Model.Patte
       case TYPE.literal:
         text(el.value);
         break;
-      case TYPE.argument:
+      case TYPE.argument: {
         checkName(el.value);
-        out.push({ type: 'expression', arg: variable(el.value) });
+        const dir = (el as { dir?: Mf2Function['dir'] }).dir;
+        out.push({
+          type: 'expression',
+          arg: variable(el.value),
+          ...(dir && { functionRef: written({ name: 'string', options: {}, dir }) }),
+        });
         break;
+      }
       case TYPE.number: {
         checkName(el.value);
         const fn = numberFunction(el);
@@ -643,10 +829,17 @@ function variable(name: string): Model.VariableRef {
   return { type: 'variable', name };
 }
 
-function functionRef(name: string, options: Record<string, string> = {}): Model.FunctionRef {
-  const entries = Object.entries(options);
+function functionRef(name: string, options: Record<string, string> = {}, args: Record<string, string> = {}): Model.FunctionRef {
+  const entries: [string, Model.Literal | Model.VariableRef][] = [
+    ...Object.entries(options).map(([k, v]): [string, Model.Literal] => [k, { type: 'literal', value: v }]),
+    ...Object.entries(args).map(([k, v]): [string, Model.VariableRef] => [k, variable(v)]),
+  ];
   if (entries.length === 0) return { type: 'function', name };
-  return { type: 'function', name, options: Object.fromEntries(entries.map(([k, v]) => [k, { type: 'literal', value: v }])) };
+  return { type: 'function', name, options: Object.fromEntries(entries) };
+}
+
+function written(fn: Mf2Function): Model.FunctionRef {
+  return functionRef(fn.name, { ...fn.options, ...(fn.dir && { 'u:dir': fn.dir }) }, fn.args);
 }
 
 function numberFunction(el: NumberElement): Model.FunctionRef {
@@ -656,7 +849,7 @@ function numberFunction(el: NumberElement): Model.FunctionRef {
     if (style === 'integer' || style === 'percent') return functionRef(style);
     throw new Error(`{${el.value}, number, ${style}} has no MessageFormat 2 equivalent`);
   }
-  if ('mf2' in style) return functionRef((style as Mf2NumberSkeleton).mf2.name, (style as Mf2NumberSkeleton).mf2.options);
+  if ('mf2' in style) return written((style as Mf2NumberSkeleton).mf2);
   const {
     style: kind,
     currency,
@@ -690,8 +883,7 @@ function numberFunction(el: NumberElement): Model.FunctionRef {
  */
 function dateFunction(el: DateElement | TimeElement): Model.FunctionRef {
   const style = el.style;
-  if (typeof style === 'object' && style !== null && 'mf2' in style)
-    return functionRef((style as Mf2DateSkeleton).mf2.name, (style as Mf2DateSkeleton).mf2.options);
+  if (typeof style === 'object' && style !== null && 'mf2' in style) return written((style as Mf2DateSkeleton).mf2);
   if (el.type === TYPE.time && (style === null || style === undefined || typeof style === 'string')) {
     const time: Record<string, Record<string, string>> = {
       short: {},

package/src/tools/migrate.ts

@@ -34,7 +34,8 @@ export interface MigratePlan {
 }
 
 export function planMigrate(config: ResolvedConfig, to: MessageFormatVersion): MigratePlan {
-  const catalog = loadCatalog(config);
+  // Both syntaxes read without isolation marks, which MF1 never has, so their renders compare.
+  const catalog = loadCatalog({ ...config, isolate: false });
   const plan: MigratePlan = { to, rewrites: [], blocked: [], changed: [] };
   for (const m of catalog.messages) {
     const versions = [
@@ -47,7 +48,7 @@ export function planMigrate(config: ResolvedConfig, to: MessageFormatVersion): M
       let back: MessageFormatElement[];
       try {
         after = writeMessage(to, ast, locale);
-        back = readMessage(to, after, locale);
+        back = readMessage(to, after, locale, false);
       } catch (e) {
         plan.blocked.push({ ...at, reason: (e as Error).message });
         continue;

package/src/tools/native/emit.ts

@@ -0,0 +1,87 @@
+/**
+ * What every native writer shares: words to identifiers, numbers and strings to literals, and the
+ * names a file can't give two things.
+ */
+import type { Condition, Operand } from './plurals.ts';
+
+/** Words from an identifier written any way: `userName`, `user-name` and `user_name` are user, name. */
+export function wordsOf(name: string): string[] {
+  return name
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((w) => w.toLowerCase());
+}
+
+const capital = (w: string) => w.charAt(0).toUpperCase() + w.slice(1);
+
+export const snake = (words: string[]) => words.join('_');
+export const pascal = (words: string[]) => words.map(capital).join('');
+export const camel = (words: string[]) => words.map((w, i) => (i === 0 ? w : capital(w))).join('');
+export const upper = (words: string[]) => words.join('_').toUpperCase();
+
+/** An identifier can't start with a digit, so `404.title` is `_404Title`. */
+export function leading(name: string): string {
+  return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+
+/** A double literal every target reads as one: `0.0`, `1.5`, `1e21`. */
+export function float(value: number): string {
+  const s = String(value).replace('e+', 'e');
+  return /[.e]/.test(s) ? s : `${s}.0`;
+}
+
+/** Characters that print nothing, or look like a space, written as escapes so the code shows them. */
+const INVISIBLE = /[\u{a0}\u{61c}\u{180e}\u{2000}-\u{200f}\u{2028}-\u{202f}\u{205f}-\u{206f}\u{feff}]/gu;
+
+/** Text for a doc comment, with what prints nothing written as `\u{…}`: Rust refuses direction marks there. */
+export function docText(line: string): string {
+  return line.replace(INVISIBLE, (c) => `\\u{${c.charCodeAt(0).toString(16)}}`);
+}
+
+/** A string literal: JSON's escapes, `\u{…}` where the target writes them so (Rust, Swift), and `$` escaped in Kotlin. */
+export function stringLiteral(value: string, language: 'rust' | 'swift' | 'kotlin'): string {
+  const json = JSON.stringify(value).replace(INVISIBLE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+  if (language === 'kotlin') return json.replaceAll('$', '\\$');
+  return json.replace(/\\u([0-9a-f]{4})/g, (_, hex: string) => `\\u{${hex.replace(/^0+/, '')}}`);
+}
+
+/**
+ * A plural condition as an expression over operands `o`: `field(op)` reads one, `mod` takes a
+ * remainder, `within` tests a range as CLDR does (integers only). `&&`, `||` and `!` are every
+ * target's.
+ */
+export function conditionCode(
+  condition: Condition,
+  code: {
+    field: (op: Operand) => string;
+    mod: (value: string, by: string) => string;
+    within: (value: string, from: string, to: string) => string;
+  },
+): string {
+  const ors = condition.map((and) =>
+    and
+      .map((r) => {
+        const value = r.mod === undefined ? code.field(r.operand) : code.mod(code.field(r.operand), float(r.mod));
+        if (r.ranges.length === 1 && r.ranges[0]![0] === r.ranges[0]![1])
+          return `${value} ${r.negated ? '!=' : '=='} ${float(r.ranges[0]![0])}`;
+        const any = r.ranges
+          .map(([from, to]) => (from === to ? `${value} == ${float(from)}` : code.within(value, float(from), float(to))))
+          .join(' || ');
+        return r.negated ? `!(${any})` : r.ranges.length > 1 ? `(${any})` : any;
+      })
+      .join(' && '),
+  );
+  return ors.length > 1 ? ors.map((o) => (o.includes(' && ') ? `(${o})` : o)).join(' || ') : ors[0]!;
+}
+
+/** Fails with the keys whose names meet, or meet a name the file already has. */
+export function checkNames(language: string, named: [key: string, name: string][], taken: string[]): void {
+  const seen = new Map<string, string>(taken.map((t) => [t, 'a name the file already has']));
+  for (const [key, name] of named) {
+    const other = seen.get(name);
+    if (other !== undefined)
+      throw new Error(`${language}: ${key} is named ${name}, as ${other} is: rename one, or change the target's keys`);
+    seen.set(name, key);
+  }
+}

package/src/tools/native/index.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+import { CatalogError, type Catalog, type Problem } from '#src/tools/catalog.ts';
+import type { Entry } from '#src/tools/compile.ts';
+import type { ResolvedConfig } from '#src/tools/config.ts';
+import { kotlinFile } from './kotlin.ts';
+import { nativeModel } from './model.ts';
+import { rustModule } from './rust.ts';
+import { swiftFile } from './swift.ts';
+
+const WRITERS = { rust: rustModule, swift: swiftFile, kotlin: kotlinFile };
+
+export function nativeFiles(
+  config: ResolvedConfig,
+  catalog: Catalog,
+  locales: string[],
+  entries: Map<string, Entry[]>,
+  banner: string,
+): Map<string, string> {
+  const files = new Map<string, string>();
+  const problems: Problem[] = [];
+  for (const target of config.native) {
+    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 as Error).message });
+    }
+  }
+  if (problems.length > 0) throw new CatalogError(problems);
+  return files;
+}