@babelize/engine 0.0.0-stage → 0.1.2

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 };

package/dist/modules/translator/language-codes/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Babelize Error Types
+ *
+ * Typed error class for structured error handling across the engine.
+ */
+export type BabelizeErrorCode = 'UNSUPPORTED_LANGUAGE' | 'TRANSLATION_FAILED' | 'INVALID_INPUT';
+export declare class BabelizeError extends Error {
+    readonly code: BabelizeErrorCode;
+    constructor(code: BabelizeErrorCode, message: string);
+}

package/dist/modules/translator/language-codes/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Babelize Error Types
+ *
+ * Typed error class for structured error handling across the engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BabelizeError = void 0;
+class BabelizeError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'BabelizeError';
+        this.code = code;
+        // Maintains proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, BabelizeError.prototype);
+    }
+}
+exports.BabelizeError = BabelizeError;

package/dist/modules/translator/language-codes/flores-map.d.ts

@@ -0,0 +1 @@
+export declare const FLORES_MAP: Record<string, string>;

package/dist/modules/translator/language-codes/flores-map.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLORES_MAP = void 0;
+exports.FLORES_MAP = {
+    af: "afr_Latn",
+    sq: "als_Latn",
+    am: "amh_Ethi",
+    ar: "arb_Arab",
+    hy: "hye_Armn",
+    az: "azj_Latn",
+    eu: "eus_Latn",
+    be: "bel_Cyrl",
+    bn: "ben_Beng",
+    bs: "bos_Latn",
+    bg: "bul_Cyrl",
+    my: "mya_Mymr",
+    ca: "cat_Latn",
+    ceb: "ceb_Latn",
+    hr: "hrv_Latn",
+    cs: "ces_Latn",
+    da: "dan_Latn",
+    nl: "nld_Latn",
+    en: "eng_Latn",
+    eo: "epo_Latn",
+    et: "est_Latn",
+    tl: "tgl_Latn",
+    fi: "fin_Latn",
+    fr: "fra_Latn",
+    gl: "glg_Latn",
+    ka: "kat_Geor",
+    de: "deu_Latn",
+    el: "ell_Grek",
+    gu: "guj_Gujr",
+    ht: "hat_Latn",
+    ha: "hau_Latn",
+    haw: "haw_Latn",
+    he: "heb_Hebr",
+    hi: "hin_Deva",
+    hmn: "hmn_Latn",
+    hu: "hun_Latn",
+    is: "isl_Latn",
+    ig: "ibo_Latn",
+    id: "ind_Latn",
+    ga: "gle_Latn",
+    it: "ita_Latn",
+    ja: "jpn_Jpan",
+    jw: "jav_Latn",
+    kn: "kan_Knda",
+    kk: "kaz_Cyrl",
+    km: "khm_Khmr",
+    ko: "kor_Hang",
+    ku: "kmr_Latn",
+    ky: "kir_Cyrl",
+    lo: "lao_Laoo",
+    la: "lat_Latn",
+    lv: "lvs_Latn",
+    lt: "lit_Latn",
+    lb: "ltz_Latn",
+    mk: "mkd_Cyrl",
+    mg: "plt_Latn",
+    ms: "zsm_Latn",
+    ml: "mal_Mlym",
+    mt: "mlt_Latn",
+    mi: "mri_Latn",
+    mr: "mar_Deva",
+    mn: "khk_Cyrl",
+    ne: "npi_Deva",
+    no: "nob_Latn",
+    nb: "nob_Latn",
+    ny: "nya_Latn",
+    ps: "pbt_Arab",
+    fa: "pes_Arab",
+    pl: "pol_Latn",
+    pt: "por_Latn",
+    pa: "pan_Guru",
+    ro: "ron_Latn",
+    ru: "rus_Cyrl",
+    sm: "smo_Latn",
+    gd: "gla_Latn",
+    sr: "srp_Cyrl",
+    st: "sot_Latn",
+    sn: "sna_Latn",
+    sd: "snd_Arab",
+    si: "sin_Sinh",
+    sk: "slk_Latn",
+    sl: "slv_Latn",
+    so: "som_Latn",
+    es: "spa_Latn",
+    su: "sun_Latn",
+    sw: "swh_Latn",
+    sv: "swe_Latn",
+    tg: "tgk_Cyrl",
+    ta: "tam_Taml",
+    te: "tel_Telu",
+    th: "tha_Thai",
+    tr: "tur_Latn",
+    uk: "ukr_Cyrl",
+    ur: "urd_Arab",
+    uz: "uzn_Latn",
+    vi: "vie_Latn",
+    cy: "cym_Latn",
+    xh: "xho_Latn",
+    yi: "ydd_Hebr",
+    yo: "yor_Latn",
+    zu: "zul_Latn",
+    zh: "zho_Hans",
+};

package/dist/modules/translator/language-codes/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Language Codes Module — barrel export
+ *
+ * Single import point for all language code utilities:
+ *   import { toFlores, isSupported, RTL_LANGUAGES } from '../modules/translator/language-codes';
+ */
+export { BabelizeError } from './errors';
+export type { BabelizeErrorCode } from './errors';
+export { FLORES_MAP } from './flores-map';
+export { toFlores, fromFlores, isSupported, isNllbSupported, getSupportedLanguages, storageLangCode, localeFromStorageCode } from './language-mapper';
+export { RTL_LANGUAGES, isRTL } from './rtl-languages';

package/dist/modules/translator/language-codes/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Language Codes Module — barrel export
+ *
+ * Single import point for all language code utilities:
+ *   import { toFlores, isSupported, RTL_LANGUAGES } from '../modules/translator/language-codes';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRTL = exports.RTL_LANGUAGES = exports.localeFromStorageCode = exports.storageLangCode = exports.getSupportedLanguages = exports.isNllbSupported = exports.isSupported = exports.fromFlores = exports.toFlores = exports.FLORES_MAP = exports.BabelizeError = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "BabelizeError", { enumerable: true, get: function () { return errors_1.BabelizeError; } });
+var flores_map_1 = require("./flores-map");
+Object.defineProperty(exports, "FLORES_MAP", { enumerable: true, get: function () { return flores_map_1.FLORES_MAP; } });
+var language_mapper_1 = require("./language-mapper");
+Object.defineProperty(exports, "toFlores", { enumerable: true, get: function () { return language_mapper_1.toFlores; } });
+Object.defineProperty(exports, "fromFlores", { enumerable: true, get: function () { return language_mapper_1.fromFlores; } });
+Object.defineProperty(exports, "isSupported", { enumerable: true, get: function () { return language_mapper_1.isSupported; } });
+Object.defineProperty(exports, "isNllbSupported", { enumerable: true, get: function () { return language_mapper_1.isNllbSupported; } });
+Object.defineProperty(exports, "getSupportedLanguages", { enumerable: true, get: function () { return language_mapper_1.getSupportedLanguages; } });
+Object.defineProperty(exports, "storageLangCode", { enumerable: true, get: function () { return language_mapper_1.storageLangCode; } });
+Object.defineProperty(exports, "localeFromStorageCode", { enumerable: true, get: function () { return language_mapper_1.localeFromStorageCode; } });
+var rtl_languages_1 = require("./rtl-languages");
+Object.defineProperty(exports, "RTL_LANGUAGES", { enumerable: true, get: function () { return rtl_languages_1.RTL_LANGUAGES; } });
+Object.defineProperty(exports, "isRTL", { enumerable: true, get: function () { return rtl_languages_1.isRTL; } });

package/dist/modules/translator/language-codes/language-mapper.d.ts

@@ -0,0 +1,25 @@
+/**
+ * FLORES-200 code for an ISO locale.
+ * - Region variants map to their language (pt-BR → por_Latn); Chinese regions
+ *   pick the script (zh-TW → zho_Hant, zh-CN → zho_Hans).
+ * - Script subtags are honoured: sr-Cyrl → srp_Cyrl, pa-Arab → pnb_Arab. A
+ *   script FLORES-200 lacks gets a FLORES-style code (sr-Latn → srp_Latn) that
+ *   only LLM providers can use — see isNllbSupported().
+ */
+export declare function toFlores(isoCode: string): string;
+export declare function fromFlores(floresCode: string): string;
+/** True when any translator can handle the locale (LLM providers use the ISO tag). */
+export declare function isSupported(isoCode: string): boolean;
+/** True when the NLLB translator service can translate into the locale. */
+export declare function isNllbSupported(isoCode: string): boolean;
+/**
+ * Key for storing translations of `isoCode` (translation cache, translation
+ * memory): the FLORES code including the script, plus the region when there
+ * is one, so variants never share translations — pt-BR → por_Latn-br,
+ * sr-Latn → srp_Latn, sr-Cyrl-RS → srp_Cyrl-rs. A plain language code keeps
+ * its FLORES code (pt → por_Latn), as before.
+ */
+export declare function storageLangCode(isoCode: string): string;
+/** BCP-47 tag for a storage code (por_Latn-br → pt-BR, srp_Latn → sr-Latn). */
+export declare function localeFromStorageCode(code: string): string;
+export declare function getSupportedLanguages(): string[];