@babelize/engine 0.1.0 → 0.1.3

package/dist/modules/lockfile/schema.d.ts

@@ -14,16 +14,31 @@ export declare const lockfileEntrySchema: z.ZodObject<{
         inTm: z.ZodOptional<z.ZodBoolean>;
         /** Pseudo-localized (`--provider pseudo`), not a translation: any real run re-translates it. */
         pseudo: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Fingerprint of the glossary rules that applied to this key's source
+         * for the locale (see glossaryFingerprint). Absent: none applied.
+         * A run whose rules give a different fingerprint re-translates it.
+         */
+        glossaryHash: z.ZodOptional<z.ZodString>;
+        /**
+         * The translation came from the project's own files (e.g. a .po
+         * catalogue), not from Babelize: glossary edits don't overwrite it.
+         */
+        external: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         sourceHash?: string | undefined;
         fromMemory?: boolean | undefined;
         inTm?: boolean | undefined;
         pseudo?: boolean | undefined;
+        glossaryHash?: string | undefined;
+        external?: boolean | undefined;
     }, {
         sourceHash?: string | undefined;
         fromMemory?: boolean | undefined;
         inTm?: boolean | undefined;
         pseudo?: boolean | undefined;
+        glossaryHash?: string | undefined;
+        external?: boolean | undefined;
     }>>>;
 }, "strip", z.ZodTypeAny, {
     sourceHash: string;
@@ -34,6 +49,8 @@ export declare const lockfileEntrySchema: z.ZodObject<{
         fromMemory?: boolean | undefined;
         inTm?: boolean | undefined;
         pseudo?: boolean | undefined;
+        glossaryHash?: string | undefined;
+        external?: boolean | undefined;
     }> | undefined;
 }, {
     sourceHash: string;
@@ -44,6 +61,8 @@ export declare const lockfileEntrySchema: z.ZodObject<{
         fromMemory?: boolean | undefined;
         inTm?: boolean | undefined;
         pseudo?: boolean | undefined;
+        glossaryHash?: string | undefined;
+        external?: boolean | undefined;
     }> | undefined;
 }>;
 export type LockfileEntry = z.infer<typeof lockfileEntrySchema>;
@@ -66,16 +85,31 @@ export declare const lockfileDataSchema: z.ZodObject<{
             inTm: z.ZodOptional<z.ZodBoolean>;
             /** Pseudo-localized (`--provider pseudo`), not a translation: any real run re-translates it. */
             pseudo: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Fingerprint of the glossary rules that applied to this key's source
+             * for the locale (see glossaryFingerprint). Absent: none applied.
+             * A run whose rules give a different fingerprint re-translates it.
+             */
+            glossaryHash: z.ZodOptional<z.ZodString>;
+            /**
+             * The translation came from the project's own files (e.g. a .po
+             * catalogue), not from Babelize: glossary edits don't overwrite it.
+             */
+            external: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             sourceHash?: string | undefined;
             fromMemory?: boolean | undefined;
             inTm?: boolean | undefined;
             pseudo?: boolean | undefined;
+            glossaryHash?: string | undefined;
+            external?: boolean | undefined;
         }, {
             sourceHash?: string | undefined;
             fromMemory?: boolean | undefined;
             inTm?: boolean | undefined;
             pseudo?: boolean | undefined;
+            glossaryHash?: string | undefined;
+            external?: boolean | undefined;
         }>>>;
     }, "strip", z.ZodTypeAny, {
         sourceHash: string;
@@ -86,6 +120,8 @@ export declare const lockfileDataSchema: z.ZodObject<{
             fromMemory?: boolean | undefined;
             inTm?: boolean | undefined;
             pseudo?: boolean | undefined;
+            glossaryHash?: string | undefined;
+            external?: boolean | undefined;
         }> | undefined;
     }, {
         sourceHash: string;
@@ -96,6 +132,8 @@ export declare const lockfileDataSchema: z.ZodObject<{
             fromMemory?: boolean | undefined;
             inTm?: boolean | undefined;
             pseudo?: boolean | undefined;
+            glossaryHash?: string | undefined;
+            external?: boolean | undefined;
         }> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
@@ -108,6 +146,8 @@ export declare const lockfileDataSchema: z.ZodObject<{
             fromMemory?: boolean | undefined;
             inTm?: boolean | undefined;
             pseudo?: boolean | undefined;
+            glossaryHash?: string | undefined;
+            external?: boolean | undefined;
         }> | undefined;
     }>;
     projectId: string;
@@ -123,6 +163,8 @@ export declare const lockfileDataSchema: z.ZodObject<{
             fromMemory?: boolean | undefined;
             inTm?: boolean | undefined;
             pseudo?: boolean | undefined;
+            glossaryHash?: string | undefined;
+            external?: boolean | undefined;
         }> | undefined;
     }>;
     projectId: string;

package/dist/modules/lockfile/schema.js

@@ -21,6 +21,17 @@ exports.lockfileEntrySchema = zod_1.z.object({
         inTm: zod_1.z.boolean().optional(),
         /** Pseudo-localized (`--provider pseudo`), not a translation: any real run re-translates it. */
         pseudo: zod_1.z.boolean().optional(),
+        /**
+         * Fingerprint of the glossary rules that applied to this key's source
+         * for the locale (see glossaryFingerprint). Absent: none applied.
+         * A run whose rules give a different fingerprint re-translates it.
+         */
+        glossaryHash: zod_1.z.string().optional(),
+        /**
+         * The translation came from the project's own files (e.g. a .po
+         * catalogue), not from Babelize: glossary edits don't overwrite it.
+         */
+        external: zod_1.z.boolean().optional(),
     })).optional(),
 });
 // ─────────────────────────────────────────────────────────────

package/dist/modules/translator/icu-branches.d.ts

@@ -0,0 +1,138 @@
+/**
+ * ICU plural/select messages for plain-text machine translation (NLLB).
+ *
+ * NLLB translates sentences, not ICU syntax. So an ICU message is taken apart
+ * into the plain sentences it can render, each sentence is translated on its
+ * own, and the translations are put back together as an ICU message for the
+ * target language:
+ *
+ * - Text around a selector is moved into its branches, so every translated
+ *   unit is a whole sentence ("You have {count, plural, one {# file} other
+ *   {# files}}." → one {You have # file.} other {You have # files.}).
+ * - A plural gets the TARGET language's CLDR categories (Polish one/few/many/
+ *   other, Japanese only other). Each category is translated from the source
+ *   branch of the same name, or the source `other`; exact `=n` branches stay.
+ * - The count (`#`, `{count}`, or a gettext `%(count)d`) is replaced by a real
+ *   number of that category (Polish few → 2, many → 5, Arabic many → 11), so
+ *   the translator inflects the words around it. The same number must come
+ *   back exactly where it can be turned back into the count; if it doesn't,
+ *   that branch — and so the message — fails.
+ * - `select` branches keep their keys; nested selectors are expanded the same
+ *   way. Anything that can't be expressed fails with a reason; a message is
+ *   never put together from a partial set of branches.
+ *
+ * Infrastructure-free: the caller sends the units to its translator and hands
+ * the per-unit results back to `compose`.
+ */
+import { type IcuNode } from '../../utils/icu-message';
+import { type FixedTerm } from '../../utils/placeholder-protection';
+import type { KeyFailure, KeyResult } from '../../providers/types';
+/** Leaves (translated sentences) one message may expand to. */
+export declare const MAX_BRANCH_UNITS = 64;
+type Selector = Extract<IcuNode, {
+    options: unknown;
+}>;
+type SelectorType = Selector['type'];
+/** A number standing in for a plural's value in one unit. */
+interface NumberSlot {
+    /** As written in the text sent to the translator, e.g. "5" or "1.5". */
+    text: string;
+    /** Occurrences in the sent text; the translation must have exactly as many. */
+    count: number;
+    /** What each occurrence turns back into (a sentinel). */
+    restore: string;
+    /** For messages: "#", "{count}", "%(count)d". */
+    label: string;
+    /**
+     * The branch stands for this one number only (`=1`, German/Polish "one",
+     * Arabic "zero"/"two"): the translation may spell it out ("eine Datei")
+     * instead of showing it, and the branch is still exact.
+     */
+    mayBeSpelledOut: boolean;
+}
+export interface BranchUnit {
+    /** Unique within the plan. */
+    id: string;
+    /** Which branch combination, e.g. "count=few" ("message" with no selectors). */
+    label: string;
+    /** Text for the translator: protected spans as [#VAR_n#] tokens, counts as numbers. */
+    sendText: string;
+    tokens: string[];
+    /** What each token is restored to (a fixed glossary term becomes its translation). */
+    restore: string[];
+    slots: NumberSlot[];
+    /** Units with nothing to translate (only a number, tags, placeholders) are not sent. */
+    passthrough: boolean;
+    /** Formatted arguments of the unit, by sentinel index. */
+    args: string[];
+    /** Literal text restored verbatim (gettext count placeholders), by sentinel index. */
+    literals: string[];
+    /** The unit's parent selector is a plural: `#` and quoting follow plural rules. */
+    inPlural: boolean;
+    /** For a passthrough unit: the text with sentinels, used as is. */
+    sentinelText: string;
+    /** Spaces were put between a count and a token it touches (see makeUnit). */
+    spaced: boolean;
+}
+export type BranchFailure = {
+    ok: false;
+    reason: KeyFailure['reason'];
+    retryable: boolean;
+    message: string;
+};
+export type BranchComposeResult = {
+    ok: true;
+    value: string;
+} | BranchFailure;
+export interface BranchPlan {
+    units: BranchUnit[];
+    /**
+     * Put the message together from one translator result per unit (by unit
+     * id). `checkUnit` adds the caller's own per-branch checks (e.g. "came back
+     * untranslated"); it returns a problem message or null.
+     */
+    compose(results: Map<string, KeyResult | undefined>, checkUnit?: (unit: BranchUnit, translated: string) => BranchFailure | null): BranchComposeResult;
+}
+export interface PlanOptions {
+    neverTranslateTerms?: string[];
+    /** "Always translate as" terms: tokenized, and restored to their translation. */
+    fixedTerms?: FixedTerm[];
+    /**
+     * Literal text standing for the value of the plural it appears in, besides
+     * `#` — e.g. "%(count)d" in a gettext plural turned into ICU.
+     */
+    valuePlaceholder?: string;
+    /**
+     * Plain (non-ICU) source: wrap it in a plural over each of these arguments
+     * for the target language (target-side plurals for `{count} files`).
+     */
+    pluralizeArgs?: string[];
+}
+/** Plural categories of a locale, CLDR order. */
+export declare function targetCategories(locale: string, type: 'cardinal' | 'ordinal'): string[];
+/** Candidate numbers for a category (or the exact value of an `=n` branch). */
+declare function numbersFor(locale: string, type: SelectorType, key: string): number[];
+/**
+ * Plan the branch-by-branch translation of `source` into `targetLocale`, or
+ * explain why it can't be done.
+ */
+export declare function planIcuBranches(source: string, targetLocale: string, options?: PlanOptions): BranchPlan | {
+    error: string;
+};
+/** "١٢" → "12", "1,5" → "1.5". */
+declare function normalizeNumber(s: string): string;
+/** Replace each slot's number in the translation by its sentinel; null when a number is missing or repeated. */
+declare function restoreNumbers(translated: string, slots: NumberSlot[]): {
+    text: string;
+} | {
+    problem: string;
+};
+/** ICU-escape literal text: apostrophes before syntax, and `{`, `}` (and `#` in a plural) quoted. */
+export declare function escapeIcuText(text: string, inPlural: boolean): string;
+/** Exposed for tests. */
+export declare const __test: {
+    normalizeNumber: typeof normalizeNumber;
+    restoreNumbers: typeof restoreNumbers;
+    numbersFor: typeof numbersFor;
+};
+export {};

package/dist/modules/translator/icu-branches.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__test = exports.MAX_BRANCH_UNITS = void 0;
+exports.targetCategories = targetCategories;
+exports.planIcuBranches = planIcuBranches;
+exports.escapeIcuText = escapeIcuText;
+/**
+ * ICU plural/select messages for plain-text machine translation (NLLB).
+ *
+ * NLLB translates sentences, not ICU syntax. So an ICU message is taken apart
+ * into the plain sentences it can render, each sentence is translated on its
+ * own, and the translations are put back together as an ICU message for the
+ * target language:
+ *
+ * - Text around a selector is moved into its branches, so every translated
+ *   unit is a whole sentence ("You have {count, plural, one {# file} other
+ *   {# files}}." → one {You have # file.} other {You have # files.}).
+ * - A plural gets the TARGET language's CLDR categories (Polish one/few/many/
+ *   other, Japanese only other). Each category is translated from the source
+ *   branch of the same name, or the source `other`; exact `=n` branches stay.
+ * - The count (`#`, `{count}`, or a gettext `%(count)d`) is replaced by a real
+ *   number of that category (Polish few → 2, many → 5, Arabic many → 11), so
+ *   the translator inflects the words around it. The same number must come
+ *   back exactly where it can be turned back into the count; if it doesn't,
+ *   that branch — and so the message — fails.
+ * - `select` branches keep their keys; nested selectors are expanded the same
+ *   way. Anything that can't be expressed fails with a reason; a message is
+ *   never put together from a partial set of branches.
+ *
+ * Infrastructure-free: the caller sends the units to its translator and hands
+ * the per-unit results back to `compose`.
+ */
+const icu_message_1 = require("../../utils/icu-message");
+const placeholder_protection_1 = require("../../utils/placeholder-protection");
+const translation_sanitizer_1 = require("../../utils/translation-sanitizer");
+/** Leaves (translated sentences) one message may expand to. */
+exports.MAX_BRANCH_UNITS = 64;
+const CLDR_ORDER = ['zero', 'one', 'two', 'few', 'many', 'other'];
+/**
+ * Numbers tried for a plural category, most natural first. NLLB tends to
+ * spell out small numbers ("five files", "fünf Akten"), which loses the
+ * count, so two- and three-digit numbers come first; 1 and 0 only where
+ * nothing else fits (a branch for exactly one number may be spelled out).
+ */
+const CANDIDATES = (() => {
+    const preferred = [25, 22, 23, 24, 21, 26, 27, 28, 29, 103, 104, 101, 102, 111, 11, 12, 13, 14, 15, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1, 0];
+    const rest = [];
+    for (let n = 16; n <= 200; n++)
+        if (!preferred.includes(n))
+            rest.push(n);
+    // Russian/Polish `other` (and similar) is only reached by fractions.
+    return [...preferred, ...rest, 1.5, 2.5, 0.5, 3.5];
+})();
+const ARG_SENTINEL = /\uE001(\d+)\uE001/g;
+const POUND_SENTINEL = '\uE002';
+const TOKEN_PATTERN = /\[\s*#\s*VAR_\d+\s*#\s*\]/gi;
+class PlanError extends Error {
+}
+/** Plural categories of a locale, CLDR order. */
+function targetCategories(locale, type) {
+    try {
+        const found = new Set(new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories);
+        return CLDR_ORDER.filter((c) => found.has(c));
+    }
+    catch {
+        return ['one', 'other'];
+    }
+}
+function rulesFor(locale, type) {
+    return new Intl.PluralRules(locale, { type: type === 'selectordinal' ? 'ordinal' : 'cardinal' });
+}
+/** Candidate numbers for a category (or the exact value of an `=n` branch). */
+function numbersFor(locale, type, key) {
+    if (/^=\d+$/.test(key))
+        return [Number(key.slice(1))];
+    const rules = rulesFor(locale, type);
+    return CANDIDATES.filter((n) => rules.select(n) === key);
+}
+/** Keys a plural gets in the target language: the source's exact `=n` keys, then each target category that has a usable number. */
+function targetKeys(sel, locale) {
+    const exact = Object.keys(sel.options).filter((k) => /^=\d+$/.test(k));
+    const cats = targetCategories(locale, sel.type === 'selectordinal' ? 'ordinal' : 'cardinal')
+        // A category reached only by huge numbers (French "many" = millions) is left
+        // to ICU's `other` fallback: such a number doesn't survive translation intact.
+        .filter((c) => c === 'other' || numbersFor(locale, sel.type, c).length > 0);
+    return [...exact, ...cats];
+}
+function sourceBranch(sel, key) {
+    const branch = sel.options[key] ?? sel.options.other;
+    if (!branch)
+        throw new PlanError(`{${sel.name}, ${sel.type}} has no "other" branch`);
+    return branch;
+}
+const isSelector = (n) => n.type === 'plural' || n.type === 'select' || n.type === 'selectordinal';
+/**
+ * Plan the branch-by-branch translation of `source` into `targetLocale`, or
+ * explain why it can't be done.
+ */
+function planIcuBranches(source, targetLocale, options = {}) {
+    try {
+        if (/,\s*(?:plural|selectordinal)\s*,\s*offset\s*:/.test(source)) {
+            throw new PlanError('plural offsets are not supported');
+        }
+        let nodes = (0, icu_message_1.parseIcu)(source);
+        for (const name of [...(options.pluralizeArgs ?? [])].reverse()) {
+            nodes = [{ type: 'plural', name, options: { other: nodes } }];
+        }
+        const units = [];
+        const tree = build(nodes, [], { units, targetLocale, options });
+        return { units, compose: (results, checkUnit) => compose(tree, results, checkUnit) };
+    }
+    catch (err) {
+        if (err instanceof PlanError || err instanceof icu_message_1.IcuParseError)
+            return { error: err.message };
+        throw err;
+    }
+}
+function build(nodes, path, state) {
+    const at = nodes.findIndex(isSelector);
+    if (at === -1) {
+        if (state.units.length >= exports.MAX_BRANCH_UNITS) {
+            throw new PlanError(`the message has more than ${exports.MAX_BRANCH_UNITS} branch combinations`);
+        }
+        const unit = makeUnit(nodes, path, state);
+        state.units.push(unit);
+        return { kind: 'leaf', unit };
+    }
+    const sel = nodes[at];
+    const prefix = nodes.slice(0, at);
+    const suffix = nodes.slice(at + 1);
+    // Moving text into the branches of `sel` must not move a `#` of an outer
+    // plural under another selector: it would then mean something else.
+    if ([...prefix, ...suffix].some((n) => n.type === 'pound')) {
+        throw new PlanError(`"#" outside the nested {${sel.name}, ${sel.type}} can't be translated branch by branch`);
+    }
+    if (path.some((p) => p.name === sel.name)) {
+        throw new PlanError(`{${sel.name}} is selected on twice`);
+    }
+    const keys = sel.type === 'select' ? Object.keys(sel.options) : targetKeys(sel, state.targetLocale);
+    if (sel.type === 'select' && !keys.includes('other')) {
+        throw new PlanError(`{${sel.name}, select} has no "other" branch`);
+    }
+    const options = keys.map((key) => [
+        key,
+        build([...prefix, ...sourceBranch(sel, key), ...suffix], [...path, { type: sel.type, name: sel.name, key }], state),
+    ]);
+    return { kind: 'selector', type: sel.type, name: sel.name, options };
+}
+function argSource(n) {
+    return n.format ? `{${n.name}, ${n.format.replace(/^(\w+),\s*/, '$1, ')}}` : `{${n.name}}`;
+}
+/** Digits already in the text (so a representative number is not confused with them). */
+function digitRuns(text) {
+    return new Set([...text.replace(TOKEN_PATTERN, ' ').matchAll(/\p{Nd}+(?:[.,٫]\p{Nd}+)?/gu)].map((m) => normalizeNumber(m[0])));
+}
+function makeUnit(nodes, path, state) {
+    const id = String(state.units.length);
+    const parent = path[path.length - 1];
+    const inPlural = !!parent && parent.type !== 'select';
+    const label = path.length ? path.map((p) => `${p.name}=${p.key}`).join(', ') : 'message';
+    const plurals = path.filter((p) => p.type !== 'select');
+    const innermostPlural = plurals[plurals.length - 1];
+    // 1. Text with sentinels: arguments, `#`, and count literals become placeholders.
+    const args = [];
+    const literals = [];
+    const occurrences = [];
+    let text = '';
+    const literal = state.options.valuePlaceholder;
+    for (const n of nodes) {
+        if (n.type === 'text') {
+            if (literal && innermostPlural && n.value.includes(literal)) {
+                const parts = n.value.split(literal);
+                parts.forEach((part, i) => {
+                    text += part;
+                    if (i < parts.length - 1) {
+                        literals.push(literal);
+                        const restore = `\uE003${literals.length - 1}\uE003`;
+                        occurrences.push({ owner: innermostPlural, kind: 'literal', restore, label: literal });
+                        text += `\uE004${occurrences.length - 1}\uE004`;
+                    }
+                });
+            }
+            else {
+                text += n.value;
+            }
+        }
+        else if (n.type === 'pound') {
+            // Only ever directly under its plural (see build()).
+            occurrences.push({ owner: parent, kind: 'pound', restore: POUND_SENTINEL, label: '#' });
+            text += `\uE004${occurrences.length - 1}\uE004`;
+        }
+        else if (n.type === 'argument') {
+            const owner = !n.format ? plurals.find((p) => p.name === n.name) : undefined;
+            args.push(argSource(n));
+            const restore = `\uE001${args.length - 1}\uE001`;
+            if (owner) {
+                occurrences.push({ owner, kind: `arg:${n.name}`, restore, label: `{${n.name}}` });
+                text += `\uE004${occurrences.length - 1}\uE004`;
+            }
+            else {
+                text += restore;
+            }
+        }
+    }
+    // 2. A number of the branch's category for each count occurrence; one number per (plural, kind).
+    const taken = digitRuns(text.replace(/[\uE001\uE003\uE004]\d+[\uE001\uE003\uE004]/g, ' '));
+    const slotsByKind = new Map();
+    const used = new Set();
+    for (const occ of occurrences) {
+        const kindKey = `${occ.owner.name}\u0000${occ.kind}`;
+        let slot = slotsByKind.get(kindKey);
+        if (!slot) {
+            const numbers = numbersFor(state.targetLocale, occ.owner.type, occ.owner.key).map(String);
+            const pick = numbers.find((n) => !taken.has(n) && !used.has(n));
+            if (pick === undefined) {
+                throw new PlanError(`no number to stand for ${occ.label} in the "${occ.owner.name}=${occ.owner.key}" branch`);
+            }
+            used.add(pick);
+            // A plural added over a plain count must show it in every branch (compareIcuMessages), so no spelling out there.
+            const mayBeSpelledOut = numbers.length === 1 && !(state.options.pluralizeArgs ?? []).includes(occ.owner.name);
+            slot = { text: pick, count: 0, restore: occ.restore, label: occ.label, mayBeSpelledOut };
+            slotsByKind.set(kindKey, slot);
+        }
+        slot.count++;
+    }
+    // Every occurrence of a literal restores the same text, so one slot (and its first sentinel) serves them all.
+    const numbered = text.replace(/\uE004(\d+)\uE004/g, (_, i) => slotsByKind.get(`${occurrences[Number(i)].owner.name}\u0000${occurrences[Number(i)].kind}`).text);
+    // 3. Protect tags, URLs and terms; arguments left as sentinels become tokens too.
+    const never = state.options.neverTranslateTerms ?? [];
+    const fixedTerms = state.options.fixedTerms ?? [];
+    const prot = (0, placeholder_protection_1.protectText)(numbered, never, { fixedTerms });
+    const tokens = [...prot.tokens];
+    const restore = [...prot.restore];
+    const tokenized = prot.text.replace(ARG_SENTINEL, (m) => {
+        tokens.push(m);
+        restore.push(m);
+        return `[#VAR_${tokens.length - 1}#]`;
+    });
+    // The translator service masks tokens as numbers (7007): a count glued to a
+    // token ("<b>5</b>") would merge into one digit run and break both. Keep
+    // them apart while translating; the space is taken out again afterwards.
+    const sendText = tokenized
+        .replace(/(\[#VAR_\d+#\])(?=\p{Nd})/gu, '$1 ')
+        .replace(/(?<=\p{Nd})(\[#VAR_\d+#\])/gu, ' $1');
+    return {
+        id,
+        label,
+        sendText,
+        spaced: sendText !== tokenized,
+        tokens,
+        restore,
+        slots: [...slotsByKind.values()],
+        passthrough: (0, placeholder_protection_1.hasNothingToTranslate)(sendText),
+        args,
+        literals,
+        inPlural,
+        sentinelText: withFixedTerms(text.replace(/\uE004(\d+)\uE004/g, (_, i) => occurrences[Number(i)].restore), never, fixedTerms),
+    };
+}
+const ZEROS = [0x30, 0x660, 0x6f0, 0x7c0, 0x966, 0x9e6, 0xa66, 0xae6, 0xb66, 0xbe6, 0xc66, 0xce6, 0xd66, 0xde6, 0xe50, 0xed0, 0xf20, 0x1040, 0x1090, 0x17e0, 0x1810, 0x1946, 0x19d0, 0xff10];
+/** "١٢" → "12", "1,5" → "1.5". */
+function normalizeNumber(s) {
+    let out = '';
+    for (const ch of s) {
+        const cp = ch.codePointAt(0);
+        const zero = ZEROS.find((z) => cp >= z && cp <= z + 9);
+        out += zero !== undefined ? String(cp - zero) : '.';
+    }
+    return out;
+}
+/** Replace each slot's number in the translation by its sentinel; null when a number is missing or repeated. */
+function restoreNumbers(translated, slots) {
+    if (slots.length === 0)
+        return { text: translated };
+    const found = new Map();
+    // Numbers only count outside [#VAR_n#] tokens.
+    const pieces = translated.split(/(\[\s*#\s*VAR_\d+\s*#\s*\])/i);
+    const out = pieces.map((piece, i) => {
+        if (i % 2 === 1)
+            return piece;
+        return piece.replace(/(?<![\p{Nd}.,٫])\p{Nd}+(?:[.,٫]\p{Nd}+)?(?![\p{Nd}])/gu, (m) => {
+            const value = normalizeNumber(m);
+            const slot = slots.find((s) => s.text === value);
+            if (!slot)
+                return m;
+            found.set(slot, (found.get(slot) ?? 0) + 1);
+            return slot.restore;
+        });
+    }).join('');
+    for (const slot of slots) {
+        const n = found.get(slot) ?? 0;
+        if (n === 0 && slot.mayBeSpelledOut)
+            continue;
+        if (n !== slot.count) {
+            return {
+                problem: n === 0
+                    ? `the number ${slot.text} standing for ${slot.label} was dropped`
+                    : `the number ${slot.text} standing for ${slot.label} appears ${n} times (expected ${slot.count})`,
+            };
+        }
+    }
+    return { text: out };
+}
+/** ICU-escape literal text: apostrophes before syntax, and `{`, `}` (and `#` in a plural) quoted. */
+function escapeIcuText(text, inPlural) {
+    const special = inPlural ? /[{}#]/ : /[{}]/;
+    let out = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "'") {
+            const next = text[i + 1];
+            out += next === undefined || /[{}#']/.test(next) ? "''" : "'";
+        }
+        else if (special.test(ch)) {
+            let j = i;
+            while (j < text.length && special.test(text[j]))
+                j++;
+            out += `'${text.slice(i, j)}'`;
+            i = j - 1;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+/** Text with sentinels → ICU source for a unit. */
+/** A passthrough branch is used as is, except that fixed glossary terms become their translation. */
+function withFixedTerms(text, never, fixedTerms) {
+    if (fixedTerms.length === 0)
+        return text;
+    const p = (0, placeholder_protection_1.protectText)(text, never, { fixedTerms });
+    return (0, placeholder_protection_1.restoreText)(p.text, p.restore);
+}
+function serializeUnit(unit, sentinelText) {
+    const parts = sentinelText.split(/(\uE001\d+\uE001|\uE002|\uE003\d+\uE003)/);
+    return parts.map((p, i) => {
+        if (i % 2 === 0)
+            return escapeIcuText(p, unit.inPlural);
+        if (p === POUND_SENTINEL)
+            return '#';
+        const arg = /^\uE001(\d+)\uE001$/.exec(p);
+        if (arg)
+            return unit.args[Number(arg[1])];
+        const lit = /^\uE003(\d+)\uE003$/.exec(p);
+        return escapeIcuText(unit.literals[Number(lit[1])], unit.inPlural);
+    }).join('');
+}
+function translateUnit(unit, result, checkUnit) {
+    const fail = (reason, retryable, message) => ({ ok: false, reason, retryable, message: `${unit.label}: ${message}` });
+    if (unit.passthrough)
+        return { ok: true, value: serializeUnit(unit, unit.sentinelText) };
+    if (!result)
+        return fail('missing_from_response', true, 'the translator returned no translation for this branch');
+    if (result.status === 'failed')
+        return fail(result.reason, result.retryable, result.message ?? `translator reported ${result.reason}`);
+    const raw = (0, translation_sanitizer_1.sanitizeTranslation)(result.value, { nllb: true, source: unit.sendText });
+    if (!raw.trim())
+        return fail('empty_value', true, 'the translator returned an empty string');
+    const tokenCheck = (0, placeholder_protection_1.checkTokens)(raw, unit.tokens.length);
+    if (!tokenCheck.ok)
+        return fail('placeholder_lost', true, `Placeholder problem: ${(0, placeholder_protection_1.describeTokenProblem)(tokenCheck, unit.tokens)}`);
+    const numbers = restoreNumbers(raw, unit.slots);
+    if ('problem' in numbers)
+        return fail('placeholder_lost', true, `Placeholder problem: ${numbers.problem}`);
+    const extra = checkUnit?.(unit, raw);
+    if (extra)
+        return { ...extra, message: `${unit.label}: ${extra.message}` };
+    // Tokens back to their text; argument tokens become sentinels again.
+    let restored = numbers.text;
+    if (unit.spaced) {
+        // Glue counts and tokens back together where the source had them glued.
+        restored = restored
+            .replace(/(\[\s*#\s*VAR_\d+\s*#\s*\])[ \u00A0]+(?=\uE002|\uE001\d+\uE001|\uE003\d+\uE003)/gi, '$1')
+            .replace(/(\uE002|\uE001\d+\uE001|\uE003\d+\uE003)[ \u00A0]+(?=\[\s*#\s*VAR_)/gi, '$1');
+    }
+    const sentinelText = restored.replace(/\[\s*#\s*VAR_(\d+)\s*#\s*\]/gi, (_, i) => unit.restore[Number(i)]);
+    return { ok: true, value: serializeUnit(unit, sentinelText) };
+}
+function compose(tree, results, checkUnit) {
+    if (tree.kind === 'leaf')
+        return translateUnit(tree.unit, results.get(tree.unit.id), checkUnit);
+    const parts = [];
+    for (const [key, child] of tree.options) {
+        const r = compose(child, results, checkUnit);
+        if (!r.ok)
+            return r;
+        parts.push(`${key} {${r.value}}`);
+    }
+    return { ok: true, value: `{${tree.name}, ${tree.type}, ${parts.join(' ')}}` };
+}
+/** Exposed for tests. */
+exports.__test = { normalizeNumber, restoreNumbers, numbersFor };