@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/i18next-icu.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATED_I18N_CONFIG_MARKER = exports.I18NEXT_WRAPPERS = void 0;
+exports.isGeneratedI18nConfig = isGeneratedI18nConfig;
+exports.detectI18nextIcu = detectI18nextIcu;
+exports.addIcuToGeneratedConfig = addIcuToGeneratedConfig;
+exports.missingIcuNote = missingIcuNote;
+const path = __importStar(require("path"));
+const types_1 = require("../runtime/types");
+const file_utils_1 = require("./file-utils");
+/** Configs often live in src/lib, which extraction skips; only skip build output and dependencies here. */
+const CONFIG_SCAN_EXCLUDES = ['node_modules', '.git', '.next', 'dist', 'build', 'out', 'coverage', '*.test.*', '*.spec.*', '*.d.ts', '*.min.js'];
+/** Libraries that call i18next's init themselves (the config is inside the library). */
+exports.I18NEXT_WRAPPERS = ['next-i18next', 'remix-i18next', 'gatsby-plugin-react-i18next'];
+/** Config files those wrappers read, relative to the project root. */
+const WRAPPER_CONFIG_FILES = [
+    'next-i18next.config.js', 'next-i18next.config.mjs', 'next-i18next.config.cjs', 'next-i18next.config.ts',
+    'gatsby-config.js', 'gatsby-config.ts', 'remix.config.js',
+];
+/** First line of i18n configs Babelize writes; Babelize may update a file that has it. */
+exports.GENERATED_I18N_CONFIG_MARKER = '// @babelize-generated i18n config';
+/**
+ * Whether an i18next config was written by Babelize: the marker, or the
+ * signature of the template from before the marker existed.
+ */
+function isGeneratedI18nConfig(content) {
+    if (content.includes(exports.GENERATED_I18N_CONFIG_MARKER))
+        return true;
+    return (content.includes('export const t = i18n.t.bind(i18n);') &&
+        content.includes("loadPath: '/locales/{{lng}}.json'") &&
+        content.includes("bindI18nStore: 'added removed'"));
+}
+const loadsIcu = (content) => /['"]i18next-icu['"]/.test(content);
+/** The file initializes i18next for React: `.use(initReactI18next)` or `i18next.init(…)`. */
+function isI18nextInit(content) {
+    if (/\.use\(\s*initReactI18next\s*\)/.test(content))
+        return true;
+    return /from\s+['"]i18next['"]|require\(\s*['"]i18next['"]\s*\)/.test(content) && /\b(?:i18n|i18next|instance)\s*(?:\.use\([^)]*\)\s*)*\.init\s*\(/.test(content);
+}
+async function readSafe(file) {
+    try {
+        return (await (0, file_utils_1.readFile)(file)) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Can a react-i18next project format ICU messages at runtime? Decided by the
+ * config that actually initializes i18next — the files calling
+ * `.use(initReactI18next)` / `i18n.init(…)`:
+ *  - a config the user owns: only if it loads i18next-icu;
+ *  - Babelize's own config: yes (finalization adds i18next-icu to older ones);
+ *  - a wrapper that owns init (next-i18next, …): only if its config loads i18next-icu;
+ *  - nothing yet: yes, Babelize will generate the config.
+ * Without ICU, placeholders would show as raw `{user}`, so sentences stay
+ * fragments until the user adds i18next-icu.
+ */
+async function detectI18nextIcu(workspace) {
+    const seen = new Set();
+    const userConfigs = [];
+    const generatedWithoutIcu = [];
+    for (const dir of new Set(['.', ...workspace.sourceDirs])) {
+        let files = [];
+        try {
+            files = (await (0, file_utils_1.findFiles)(path.join(workspace.path, dir), types_1.SUPPORTED_EXTENSIONS, CONFIG_SCAN_EXCLUDES)) ?? [];
+        }
+        catch {
+            files = [];
+        }
+        for (const file of files) {
+            if (seen.has(file) || /[\\/]node_modules[\\/]/.test(file))
+                continue;
+            seen.add(file);
+            const content = await readSafe(file);
+            if (!isI18nextInit(content))
+                continue;
+            const rel = path.relative(workspace.path, file).split(path.sep).join('/');
+            if (isGeneratedI18nConfig(content)) {
+                if (!loadsIcu(content))
+                    generatedWithoutIcu.push(rel);
+            }
+            else {
+                userConfigs.push({ rel, icu: loadsIcu(content) });
+            }
+        }
+    }
+    if (userConfigs.length > 0) {
+        const without = userConfigs.find((c) => !c.icu);
+        return { available: !without, userOwnsInit: true, userConfig: without?.rel, generatedWithoutIcu };
+    }
+    const deps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
+    const wrapper = exports.I18NEXT_WRAPPERS.find((w) => deps[w]);
+    if (wrapper) {
+        let icu = false;
+        for (const name of WRAPPER_CONFIG_FILES) {
+            const file = path.join(workspace.path, name);
+            if ((await (0, file_utils_1.pathExists)(file).catch(() => false)) && loadsIcu(await readSafe(file)))
+                icu = true;
+        }
+        return { available: icu, userOwnsInit: true, wrapper, generatedWithoutIcu };
+    }
+    return { available: true, userOwnsInit: false, generatedWithoutIcu };
+}
+/** Add i18next-icu to a Babelize-generated config (idempotent). */
+function addIcuToGeneratedConfig(content) {
+    if (loadsIcu(content))
+        return content;
+    const importLine = "import ICU from 'i18next-icu';";
+    let out = content;
+    const detector = /^import LanguageDetector from ['"]i18next-browser-languagedetector['"];?\r?\n/m;
+    if (detector.test(out))
+        out = out.replace(detector, (m) => `${m}${importLine}\n`);
+    else
+        out = out.replace(/^(import i18n from ['"]i18next['"];?\r?\n)/m, `$1${importLine}\n`);
+    return out.replace(/\.use\(initReactI18next\)/, '.use(ICU)\n  .use(initReactI18next)');
+}
+/** The note shown when sentences stay fragments because the runtime can't format ICU. */
+function missingIcuNote(status) {
+    if (status.available)
+        return null;
+    if (status.wrapper) {
+        return `${status.wrapper} initializes i18next without i18next-icu, so JSX sentences with variables were kept as separate fragments. Add i18next-icu to enable full-sentence translation (add it to the \`use\` option of your ${status.wrapper} config).`;
+    }
+    return `${status.userConfig} doesn't load i18next-icu, so JSX sentences with variables were kept as separate fragments. Add i18next-icu to enable full-sentence translation: \`import ICU from 'i18next-icu'\` and \`.use(ICU)\`.`;
+}

package/dist/utils/icu-message.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Minimal ICU MessageFormat parser and validator for translated messages.
+ *
+ * ICU messages can't be tokenized like simple placeholders: a translation
+ * legitimately changes their structure (Polish needs `few`/`many` plural
+ * branches English doesn't have). So instead of protecting them, we let the
+ * model rewrite the whole message and then check the result is still a valid
+ * message with the same arguments and selector branches.
+ *
+ * Covers what UI strings use: simple and formatted arguments, plural,
+ * selectordinal (with offset and =n keys), select, `#`, and apostrophe
+ * quoting. Not a full ICU implementation (no nested formatting skeletons).
+ */
+export type IcuNode = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'pound';
+} | {
+    type: 'argument';
+    name: string;
+    format?: string;
+} | {
+    type: 'plural' | 'selectordinal' | 'select';
+    name: string;
+    options: Record<string, IcuNode[]>;
+};
+export declare class IcuParseError extends Error {
+}
+export declare function parseIcu(message: string): IcuNode[];
+/** True when the message uses plural/select/selectordinal syntax. */
+export declare function isIcuMessage(message: string): boolean;
+export interface IcuIssue {
+    severity: 'error' | 'warning';
+    code: 'icu_invalid' | 'icu_arguments_changed' | 'icu_selector_removed' | 'icu_selector_added' | 'icu_branch_lost_argument' | 'icu_select_keys_changed' | 'icu_plural_category_invalid' | 'icu_missing_other' | 'icu_plural_category_missing';
+    message: string;
+}
+/**
+ * Compare a translated ICU message to its source. Errors mean the message is
+ * broken at runtime (unparseable, arguments renamed, select branches changed,
+ * no `other`). Missing target plural categories are only a warning: ICU
+ * falls back to `other` for them.
+ */
+export declare function compareIcuMessages(source: string, translated: string, targetLocale: string, options?: {
+    /**
+     * Simple arguments of the source the translation may turn into a plural
+     * (the count-like ones the engine flagged). A plural over any other
+     * argument is an error: `{name, plural, …}` formats a name as NaN.
+     */
+    pluralizable?: string[];
+}): IcuIssue[];
+export declare function isCountLikeName(name: string): boolean;
+/**
+ * Simple `{name}` arguments of a non-ICU message that look like counts. A
+ * translation may turn such an argument into a plural for languages that
+ * inflect words by number, without the source having to.
+ */
+export declare function countArguments(message: string): string[];
+/** Single-brace `{name}` arguments (not `{{name}}`). */
+export declare function extractSimpleArguments(message: string): string[];
+/** CLDR plural categories a translator should produce for this locale. */
+export declare function requiredPluralCategories(locale: string): {
+    cardinal: string[];
+    ordinal: string[];
+};

package/dist/utils/icu-message.js

@@ -0,0 +1,346 @@
+"use strict";
+/**
+ * Minimal ICU MessageFormat parser and validator for translated messages.
+ *
+ * ICU messages can't be tokenized like simple placeholders: a translation
+ * legitimately changes their structure (Polish needs `few`/`many` plural
+ * branches English doesn't have). So instead of protecting them, we let the
+ * model rewrite the whole message and then check the result is still a valid
+ * message with the same arguments and selector branches.
+ *
+ * Covers what UI strings use: simple and formatted arguments, plural,
+ * selectordinal (with offset and =n keys), select, `#`, and apostrophe
+ * quoting. Not a full ICU implementation (no nested formatting skeletons).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcuParseError = void 0;
+exports.parseIcu = parseIcu;
+exports.isIcuMessage = isIcuMessage;
+exports.compareIcuMessages = compareIcuMessages;
+exports.isCountLikeName = isCountLikeName;
+exports.countArguments = countArguments;
+exports.extractSimpleArguments = extractSimpleArguments;
+exports.requiredPluralCategories = requiredPluralCategories;
+class IcuParseError extends Error {
+}
+exports.IcuParseError = IcuParseError;
+function parseIcu(message) {
+    let pos = 0;
+    const fail = (msg) => {
+        throw new IcuParseError(`${msg} at position ${pos}`);
+    };
+    const skipSpace = () => {
+        while (pos < message.length && /\s/.test(message[pos]))
+            pos++;
+    };
+    const readIdentifier = () => {
+        skipSpace();
+        const start = pos;
+        while (pos < message.length && /[^\s,{}#]/.test(message[pos]))
+            pos++;
+        if (pos === start)
+            fail('Expected identifier');
+        return message.slice(start, pos);
+    };
+    const parseMessage = (inPlural, depth) => {
+        const nodes = [];
+        let text = '';
+        const flush = () => {
+            if (text)
+                nodes.push({ type: 'text', value: text });
+            text = '';
+        };
+        while (pos < message.length) {
+            const ch = message[pos];
+            if (ch === "'") {
+                // '' is a literal apostrophe; '{…}' / '#…' quotes syntax characters.
+                if (message[pos + 1] === "'") {
+                    text += "'";
+                    pos += 2;
+                    continue;
+                }
+                const next = message[pos + 1];
+                if (next === '{' || next === '}' || (inPlural && next === '#')) {
+                    const end = message.indexOf("'", pos + 1);
+                    if (end === -1)
+                        fail('Unterminated quote');
+                    text += message.slice(pos + 1, end);
+                    pos = end + 1;
+                    continue;
+                }
+                text += ch;
+                pos++;
+                continue;
+            }
+            if (ch === '#' && inPlural) {
+                flush();
+                nodes.push({ type: 'pound' });
+                pos++;
+                continue;
+            }
+            if (ch === '}') {
+                if (depth === 0)
+                    fail('Unbalanced }');
+                break;
+            }
+            if (ch === '{') {
+                flush();
+                nodes.push(parseArgument(depth));
+                continue;
+            }
+            text += ch;
+            pos++;
+        }
+        flush();
+        return nodes;
+    };
+    const parseArgument = (depth) => {
+        pos++; // {
+        const name = readIdentifier();
+        skipSpace();
+        if (message[pos] === '}') {
+            pos++;
+            return { type: 'argument', name };
+        }
+        if (message[pos] !== ',')
+            fail('Expected , or }');
+        pos++;
+        const kind = readIdentifier();
+        skipSpace();
+        if (kind === 'plural' || kind === 'selectordinal' || kind === 'select') {
+            if (message[pos] !== ',')
+                fail(`Expected , after ${kind}`);
+            pos++;
+            const options = {};
+            skipSpace();
+            if (kind !== 'select' && message.startsWith('offset:', pos)) {
+                pos += 'offset:'.length;
+                readIdentifier();
+            }
+            while (true) {
+                skipSpace();
+                if (message[pos] === '}') {
+                    pos++;
+                    break;
+                }
+                if (pos >= message.length)
+                    fail(`Unterminated ${kind}`);
+                const key = readIdentifier();
+                skipSpace();
+                if (message[pos] !== '{')
+                    fail(`Expected { after option "${key}"`);
+                if (key in options)
+                    fail(`Duplicate option "${key}"`);
+                pos++;
+                options[key] = parseMessage(kind !== 'select', depth + 1);
+                if (message[pos] !== '}')
+                    fail(`Unterminated option "${key}"`);
+                pos++;
+            }
+            if (Object.keys(options).length === 0)
+                fail(`${kind} has no options`);
+            return { type: kind, name, options };
+        }
+        // Formatted argument: {price, number} / {d, date, short} — keep the rest verbatim.
+        let format = kind;
+        if (message[pos] === ',') {
+            const end = message.indexOf('}', pos);
+            if (end === -1)
+                fail('Unterminated argument');
+            format += message.slice(pos, end);
+            pos = end;
+        }
+        skipSpace();
+        if (message[pos] !== '}')
+            fail('Expected }');
+        pos++;
+        return { type: 'argument', name, format };
+    };
+    const nodes = parseMessage(false, 0);
+    if (pos < message.length)
+        fail('Unexpected }');
+    return nodes;
+}
+/** True when the message uses plural/select/selectordinal syntax. */
+function isIcuMessage(message) {
+    return /\{\s*[\w.]+\s*,\s*(?:plural|select|selectordinal)\s*,/.test(message);
+}
+function collect(nodes, args, selectors, texts) {
+    for (const node of nodes) {
+        if (node.type === 'text')
+            texts.push(node.value);
+        else if (node.type === 'argument')
+            args.add(node.name);
+        else if (node.type !== 'pound') {
+            args.add(node.name);
+            selectors.push({ kind: node.type, name: node.name, keys: Object.keys(node.options), branches: Object.values(node.options) });
+            for (const branch of Object.values(node.options))
+                collect(branch, args, selectors, texts);
+        }
+    }
+}
+const CLDR_ORDER = ['zero', 'one', 'two', 'few', 'many', 'other'];
+/** Plural categories for a locale, always in CLDR order (runtimes differ in ordering). */
+function pluralCategories(locale, type) {
+    try {
+        const found = new Set(new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories);
+        return CLDR_ORDER.filter((c) => found.has(c));
+    }
+    catch {
+        return [...CLDR_ORDER];
+    }
+}
+/**
+ * Compare a translated ICU message to its source. Errors mean the message is
+ * broken at runtime (unparseable, arguments renamed, select branches changed,
+ * no `other`). Missing target plural categories are only a warning: ICU
+ * falls back to `other` for them.
+ */
+function compareIcuMessages(source, translated, targetLocale, options = {}) {
+    let sourceAst;
+    try {
+        sourceAst = parseIcu(source);
+    }
+    catch {
+        // Source isn't valid ICU itself; nothing meaningful to compare.
+        return [];
+    }
+    let targetAst;
+    try {
+        targetAst = parseIcu(translated);
+    }
+    catch (err) {
+        return [{ severity: 'error', code: 'icu_invalid', message: `Translation is not a valid ICU message: ${err.message}` }];
+    }
+    const issues = [];
+    const srcArgs = new Set();
+    const tgtArgs = new Set();
+    const srcSelectors = [];
+    const tgtSelectors = [];
+    collect(sourceAst, srcArgs, srcSelectors, []);
+    collect(targetAst, tgtArgs, tgtSelectors, []);
+    const missingArgs = [...srcArgs].filter((a) => !tgtArgs.has(a));
+    const extraArgs = [...tgtArgs].filter((a) => !srcArgs.has(a));
+    if (missingArgs.length || extraArgs.length) {
+        issues.push({
+            severity: 'error',
+            code: 'icu_arguments_changed',
+            message: [
+                missingArgs.length ? `missing {${missingArgs.join('}, {')}}` : '',
+                extraArgs.length ? `unknown {${extraArgs.join('}, {')}}` : '',
+            ].filter(Boolean).join('; '),
+        });
+    }
+    // A plural/select dropped from the translation (e.g. "{count} fichiers")
+    // still renders, but wrongly for every count but one.
+    for (const src of srcSelectors) {
+        if (!tgtSelectors.some((t) => t.name === src.name && t.kind === src.kind)) {
+            issues.push({
+                severity: 'error',
+                code: 'icu_selector_removed',
+                message: `{${src.name}, ${src.kind}} was removed from the translation`,
+            });
+        }
+    }
+    // A translation may add a plural over a simple argument of the source:
+    // "{files} files" → Polish "{files, plural, one {# plik} few {# pliki} …}".
+    // Only a cardinal plural, and every branch must still show the number.
+    for (const target of tgtSelectors) {
+        if (srcSelectors.some((s) => s.name === target.name && s.kind === target.kind))
+            continue;
+        if (target.kind !== 'plural') {
+            issues.push({ severity: 'error', code: 'icu_selector_added', message: `{${target.name}, ${target.kind}} is not in the source; only a plural may be added` });
+            continue;
+        }
+        if (!(options.pluralizable ?? []).includes(target.name)) {
+            issues.push({ severity: 'error', code: 'icu_selector_added', message: `{${target.name}} is not a number; don't add a plural over it` });
+            continue;
+        }
+        const lost = target.keys.filter((k, i) => !mentions(target.branches[i], target.name));
+        if (lost.length) {
+            issues.push({
+                severity: 'error',
+                code: 'icu_branch_lost_argument',
+                message: `{${target.name}, plural} branches [${lost.join(', ')}] don't show the number (use # or {${target.name}})`,
+            });
+        }
+    }
+    for (const target of tgtSelectors) {
+        if (!target.keys.includes('other')) {
+            issues.push({ severity: 'error', code: 'icu_missing_other', message: `{${target.name}, ${target.kind}} has no "other" branch` });
+        }
+        if (target.kind === 'select') {
+            const source = srcSelectors.find((s) => s.kind === 'select' && s.name === target.name);
+            if (source && [...source.keys].sort().join('|') !== [...target.keys].sort().join('|')) {
+                issues.push({
+                    severity: 'error',
+                    code: 'icu_select_keys_changed',
+                    message: `{${target.name}, select} branches changed from [${source.keys.join(', ')}] to [${target.keys.join(', ')}]`,
+                });
+            }
+            continue;
+        }
+        const allowed = pluralCategories(targetLocale, target.kind === 'selectordinal' ? 'ordinal' : 'cardinal');
+        const invalid = target.keys.filter((k) => !/^=\d+$/.test(k) && !allowed.includes(k));
+        if (invalid.length) {
+            issues.push({
+                severity: 'error',
+                code: 'icu_plural_category_invalid',
+                message: `{${target.name}, ${target.kind}} uses categories [${invalid.join(', ')}] that ${targetLocale} doesn't have (valid: ${allowed.join(', ')})`,
+            });
+        }
+        const missing = allowed.filter((c) => !target.keys.includes(c));
+        if (missing.length) {
+            issues.push({
+                severity: 'warning',
+                code: 'icu_plural_category_missing',
+                message: `{${target.name}, ${target.kind}} has no [${missing.join(', ')}] branch for ${targetLocale}; "other" will be used`,
+            });
+        }
+    }
+    return issues;
+}
+/** Whether a plural branch shows its number: `#`, or `{name}` (also inside nested selectors). */
+function mentions(nodes, name) {
+    return nodes.some((n) => n.type === 'pound' ||
+        (n.type === 'argument' && n.name === name) ||
+        ((n.type === 'plural' || n.type === 'select' || n.type === 'selectordinal') && Object.values(n.options).some((b) => mentions(b, name))));
+}
+/** Argument names that read like counts (`count`, `total`, `itemCount`, `items.length` → itemsLength). */
+const COUNT_NAME = /^(?:count|total|num|n|length)$|(?:Count|Length)$/;
+/** Argument names that are a plural noun, i.e. how many of them (`{files}`, `{unreadMessages}`). */
+const COUNTED_NOUNS = new Set([
+    'attempts', 'comments', 'credits', 'days', 'documents', 'entries', 'errors', 'events', 'files', 'followers',
+    'hours', 'images', 'issues', 'items', 'keys', 'licenses', 'likes', 'members', 'messages', 'minutes',
+    'notifications', 'orders', 'pages', 'photos', 'points', 'products', 'projects', 'records', 'results', 'rows',
+    'seats', 'seconds', 'steps', 'tasks', 'users', 'views', 'warnings', 'weeks', 'months', 'years', 'people',
+]);
+function isCountLikeName(name) {
+    if (COUNT_NAME.test(name))
+        return true;
+    const last = name.split(/(?=[A-Z])|_/).pop().toLowerCase();
+    return COUNTED_NOUNS.has(last);
+}
+/**
+ * Simple `{name}` arguments of a non-ICU message that look like counts. A
+ * translation may turn such an argument into a plural for languages that
+ * inflect words by number, without the source having to.
+ */
+function countArguments(message) {
+    // Only ICU-style messages: i18next `{{count}}`, printf and template
+    // placeholders keep token protection and its checks.
+    if (isIcuMessage(message) || /\{\{|\}\}|%(?:\(\w+\))?[sd]|\$\{/.test(message))
+        return [];
+    return extractSimpleArguments(message).filter(isCountLikeName);
+}
+/** Single-brace `{name}` arguments (not `{{name}}`). */
+function extractSimpleArguments(message) {
+    const names = new Set();
+    for (const m of message.matchAll(/(?<!\{)\{\s*([A-Za-z_]\w*)\s*\}(?!\})/g))
+        names.add(m[1]);
+    return [...names];
+}
+/** CLDR plural categories a translator should produce for this locale. */
+function requiredPluralCategories(locale) {
+    return { cardinal: pluralCategories(locale, 'cardinal'), ordinal: pluralCategories(locale, 'ordinal') };
+}

package/dist/utils/icu-spans.d.ts

@@ -0,0 +1,10 @@
+/** Span differences of `target` per branch combination (empty when fine). */
+export declare function branchSpanProblems(source: string, target: string, neverTranslate?: string[]): BranchSpanProblem[];
+export interface BranchSpanProblem {
+    /** Which branch combination, e.g. "count=other" ("message" when the target has no selectors). */
+    branch: string;
+    lost: string[];
+    added: string[];
+}
+/** "count=other: lost <b>, </b>" */
+export declare function describeBranchSpanProblem(p: BranchSpanProblem): string;