@babelize/engine 0.1.0 → 0.1.3

package/dist/django/extract.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Entry point for extracting a Django project file into engine strings.
+ */
+import type { ExtractedString, NotInjectedString, Warning } from '../runtime/types';
+import type { DjangoFileAnalysis, TemplateEdit } from './types';
+/** A Django template: an .html/.txt file inside a `templates` directory (not Jinja2). */
+export declare function isDjangoTemplatePath(rel: string): boolean;
+export declare function isDjangoPythonSource(rel: string): boolean;
+export declare function analyzeDjangoFile(content: string, rel: string): (DjangoFileAnalysis & {
+    extraEdits: TemplateEdit[];
+}) | null;
+/** Extraction id of a finding; injection matches findings back by it. */
+export declare function findingId(rel: string, line: number, msgctxt: string | undefined, msgid: string, plural: string | undefined, editStart?: number): string;
+export declare function extractDjangoFile(content: string, rel: string, options?: {
+    icu?: boolean;
+}): {
+    strings: ExtractedString[];
+    warnings: Warning[];
+    notInjected: NotInjectedString[];
+};

package/dist/django/extract.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Entry point for extracting a Django project file into engine strings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDjangoTemplatePath = isDjangoTemplatePath;
+exports.isDjangoPythonSource = isDjangoPythonSource;
+exports.analyzeDjangoFile = analyzeDjangoFile;
+exports.findingId = findingId;
+exports.extractDjangoFile = extractDjangoFile;
+const crypto_1 = require("crypto");
+const python_extract_1 = require("./python-extract");
+const template_extract_1 = require("./template-extract");
+/** Python files that are not application code shown to users. */
+const NON_APP_PY = /(?:^|\/)(?:manage|setup|conftest|wsgi|asgi|settings|tests|test_[^/]*|[^/]*_tests?)\.py$|(?:^|\/)settings\/[^/]+\.py$/;
+/** A Django template: an .html/.txt file inside a `templates` directory (not Jinja2). */
+function isDjangoTemplatePath(rel) {
+    const p = rel.replace(/\\/g, '/');
+    return /\.html?$/i.test(p) && /(?:^|\/)templates\//.test(p) && !/(?:^|\/)jinja2\//.test(p);
+}
+function isDjangoPythonSource(rel) {
+    const p = rel.replace(/\\/g, '/');
+    return p.endsWith('.py') && !NON_APP_PY.test(p) && !/(?:^|\/)migrations\//.test(p);
+}
+function analyzeDjangoFile(content, rel) {
+    if (isDjangoPythonSource(rel))
+        return { ...(0, python_extract_1.extractDjangoPython)(content, { filePath: rel }), extraEdits: [] };
+    if (isDjangoTemplatePath(rel))
+        return (0, template_extract_1.extractDjangoTemplate)(content, { filePath: rel });
+    return null;
+}
+function messageHash(msgctxt, msgid, plural) {
+    return (0, crypto_1.createHash)('sha1').update(`${msgctxt ?? ''}\u0004${msgid}\u0000${plural ?? ''}`).digest('hex').slice(0, 12);
+}
+/** Extraction id of a finding; injection matches findings back by it. */
+function findingId(rel, line, msgctxt, msgid, plural, editStart) {
+    const base = `${rel}:${line}:${messageHash(msgctxt, msgid, plural)}`;
+    return editStart === undefined ? base : `${base}:${editStart}`;
+}
+function extractDjangoFile(content, rel, options = {}) {
+    const analysis = analyzeDjangoFile(content, rel);
+    if (!analysis)
+        return { strings: [], warnings: [], notInjected: [] };
+    const strings = [];
+    const seen = new Set();
+    for (const f of analysis.findings) {
+        const m = f.message;
+        const id = findingId(rel, f.line, m.msgctxt, m.msgid, m.msgidPlural, f.edit?.start);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        strings.push({
+            text: m.msgid,
+            file: rel,
+            line: f.line,
+            column: 0,
+            context: rel.endsWith('.py') ? 'string-literal' : 'jsx-text',
+            id,
+            parentContext: m.msgctxt,
+            offsets: f.edit ? [f.edit.start] : undefined,
+            gettext: {
+                msgid: m.msgid,
+                msgidPlural: m.msgidPlural,
+                msgctxt: m.msgctxt,
+                flags: m.flags,
+                comments: m.comments,
+                wrapped: f.wrapped,
+                icu: options.icu,
+            },
+        });
+    }
+    const notInjected = analysis.unwired.map((u) => ({
+        file: rel,
+        key: '',
+        text: u.text,
+        reason: `line ${u.line}: ${u.reason}`,
+    }));
+    return { strings, warnings: [], notInjected };
+}

package/dist/django/inject-file.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Injection phase for one Django file: re-analyze it, wrap the hardcoded
+ * strings extraction selected (by extraction id), and report each wrap.
+ */
+import type { FileInjection } from '../runtime/types';
+export declare function injectDjangoFile(content: string, rel: string, fileKeys: Map<string, string>): FileInjection;

package/dist/django/inject-file.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Injection phase for one Django file: re-analyze it, wrap the hardcoded
+ * strings extraction selected (by extraction id), and report each wrap.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectDjangoFile = injectDjangoFile;
+const extract_1 = require("./extract");
+const inject_1 = require("./inject");
+function injectDjangoFile(content, rel, fileKeys) {
+    const unchanged = { file: rel, originalContent: content, modifiedContent: content, injections: [], importAdded: false, hookAdded: false };
+    const analysis = (0, extract_1.analyzeDjangoFile)(content, rel);
+    if (!analysis)
+        return unchanged;
+    const injections = [];
+    const pyEdits = [];
+    const tplEdits = [];
+    for (const f of analysis.findings) {
+        if (!f.edit)
+            continue;
+        const m = f.message;
+        const key = fileKeys.get((0, extract_1.findingId)(rel, f.line, m.msgctxt, m.msgid, m.msgidPlural, f.edit.start));
+        if (!key)
+            continue;
+        if (f.edit.kind === 'python')
+            pyEdits.push(f.edit);
+        else
+            tplEdits.push(f.edit);
+        injections.push({
+            file: rel,
+            line: f.line,
+            column: 0,
+            original: content.slice(f.edit.start, f.edit.end),
+            replacement: f.edit.kind === 'template' ? f.edit.replacement : `gettext(${f.edit.inner})${f.edit.suffix}`,
+            key,
+            confidence: 100,
+        });
+    }
+    if (injections.length === 0)
+        return unchanged;
+    const modifiedContent = rel.endsWith('.py')
+        ? (0, inject_1.injectPython)(content, pyEdits)
+        : (0, inject_1.injectTemplate)(content, [...tplEdits, ...analysis.extraEdits]);
+    return {
+        file: rel,
+        originalContent: content,
+        modifiedContent,
+        injections,
+        importAdded: modifiedContent !== content,
+        hookAdded: false,
+    };
+}

package/dist/django/inject.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Apply the edits found by the Django extractors: wrap hardcoded strings in
+ * gettext / gettext_lazy (adding the import) or translate tags (adding
+ * `{% load i18n %}`). Edits replace exact source spans, so the rest of the
+ * file — formatting, comments, line endings — is unchanged.
+ */
+import type { PythonEdit, TemplateEdit } from './types';
+/** Insert `{% load i18n %}` after `{% extends %}` (which must stay first), or at the top. */
+export declare function ensureLoadI18n(src: string): string;
+export declare function injectTemplate(src: string, edits: TemplateEdit[]): string;
+export declare function injectPython(src: string, edits: PythonEdit[]): string;

package/dist/django/inject.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Apply the edits found by the Django extractors: wrap hardcoded strings in
+ * gettext / gettext_lazy (adding the import) or translate tags (adding
+ * `{% load i18n %}`). Edits replace exact source spans, so the rest of the
+ * file — formatting, comments, line endings — is unchanged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureLoadI18n = ensureLoadI18n;
+exports.injectTemplate = injectTemplate;
+exports.injectPython = injectPython;
+const python_lexer_1 = require("./python-lexer");
+function applySpans(src, edits) {
+    // Non-overlapping, applied back to front so earlier offsets stay valid.
+    const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+    let out = src;
+    let limit = Infinity;
+    for (const e of sorted) {
+        if (e.end > limit)
+            continue; // overlaps an edit already applied
+        out = out.slice(0, e.start) + e.text + out.slice(e.end);
+        limit = e.start;
+    }
+    return out;
+}
+function newlineOf(src) {
+    return src.includes('\r\n') ? '\r\n' : '\n';
+}
+// ── Templates ────────────────────────────────────────────────
+const LOAD_I18N = /\{%\s*load\s+(?:[\w.]+\s+)*i18n(?:\s+[\w.]+)*\s*%\}/;
+/** Insert `{% load i18n %}` after `{% extends %}` (which must stay first), or at the top. */
+function ensureLoadI18n(src) {
+    if (LOAD_I18N.test(src))
+        return src;
+    const nl = newlineOf(src);
+    const ext = /\{%\s*extends\s[^%]*%\}[ \t]*(\r?\n)?/.exec(src);
+    if (ext) {
+        const at = ext.index + ext[0].length;
+        return ext[1] ? `${src.slice(0, at)}{% load i18n %}${nl}${src.slice(at)}` : `${src.slice(0, at)}${nl}{% load i18n %}${nl}${src.slice(at)}`;
+    }
+    return `{% load i18n %}${nl}${src}`;
+}
+function injectTemplate(src, edits) {
+    if (edits.length === 0)
+        return src;
+    const out = applySpans(src, edits.map((e) => ({ start: e.start, end: e.end, text: e.replacement })));
+    return ensureLoadI18n(out);
+}
+function existingImports(src, tokens) {
+    const local = new Map();
+    let extendable;
+    for (const ln of (0, python_lexer_1.logicalLines)(src, tokens)) {
+        const t = ln.tokens;
+        if (ln.indent !== 0 || t[0]?.value !== 'from')
+            continue;
+        const mod = t.slice(1, t.findIndex((x) => x.value === 'import')).map((x) => x.value).join('');
+        if (mod !== 'django.utils.translation')
+            continue;
+        const importAt = t.findIndex((x) => x.value === 'import');
+        const names = t.slice(importAt + 1).filter((x) => x.value !== '(' && x.value !== ')');
+        for (let k = 0; k < names.length; k++) {
+            if (names[k].type !== 'name')
+                continue;
+            if (names[k + 1]?.value === 'as') {
+                local.set(names[k + 2].value, names[k].value);
+                k += 2;
+            }
+            else {
+                local.set(names[k].value, names[k].value);
+            }
+        }
+        const last = t[t.length - 1];
+        const text = src.slice(t[0].start, last.end);
+        if (!text.includes('(') && !text.includes('\n') && !text.includes('\\'))
+            extendable = { end: last.end, text };
+    }
+    return { local, extendable };
+}
+/** Is `_` taken by something other than Django's gettext in this file? */
+function underscoreTaken(tokens, imports) {
+    if (imports.local.has('_'))
+        return false;
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.type !== 'name' || t.value !== '_')
+            continue;
+        if (tokens[i + 1]?.value === '(') {
+            // `def _(` defines it; `_(` alone is a call to something already named `_`.
+            if (tokens[i - 1]?.value === 'def')
+                return true;
+            return true;
+        }
+        return true; // `for _ in …`, `x, _ = …`, `import foo as _`
+    }
+    return false;
+}
+/** Where a new import line goes: after the last top-level import of the leading block. */
+function importInsertPoint(src, tokens) {
+    const lines = (0, python_lexer_1.logicalLines)(src, tokens);
+    let lastImportEnd = -1;
+    let lastDjangoImportEnd = -1;
+    let afterDocstring = -1;
+    for (let idx = 0; idx < lines.length; idx++) {
+        const ln = lines[idx];
+        if (ln.indent !== 0) {
+            if (lastImportEnd !== -1)
+                break;
+            continue;
+        }
+        const first = ln.tokens[0];
+        if (idx === 0 && first.type === 'string' && ln.tokens.length === 1) {
+            afterDocstring = first.end;
+            continue;
+        }
+        if (first.value === 'import' || first.value === 'from') {
+            lastImportEnd = ln.tokens[ln.tokens.length - 1].end;
+            // Keep the Django imports together (isort's third-party section).
+            if (ln.tokens[1]?.value === 'django')
+                lastDjangoImportEnd = lastImportEnd;
+            continue;
+        }
+        if (first.value === 'try' || first.value === 'except' || first.value === 'if') {
+            // Conditional imports: stop scanning, keep what we have.
+            break;
+        }
+        break;
+    }
+    const anchor = lastDjangoImportEnd !== -1 ? lastDjangoImportEnd : lastImportEnd !== -1 ? lastImportEnd : afterDocstring;
+    if (anchor === -1) {
+        // Top of file, after a shebang / encoding comment block.
+        let offset = 0;
+        const header = /^(?:#![^\n]*\n|#[^\n]*coding[:=][^\n]*\n)+/.exec(src);
+        if (header)
+            offset = header[0].length;
+        return { offset, before: true };
+    }
+    const eol = src.indexOf('\n', anchor);
+    return { offset: eol === -1 ? src.length : eol + 1, before: false };
+}
+function injectPython(src, edits) {
+    if (edits.length === 0)
+        return src;
+    const tokens = (0, python_lexer_1.tokenizePython)(src);
+    const imports = existingImports(src, tokens);
+    const needLazy = edits.some((e) => e.lazy);
+    const needEager = edits.some((e) => !e.lazy);
+    const nl = newlineOf(src);
+    const findLocal = (imported, alt) => {
+        for (const [loc, imp] of imports.local)
+            if (imp === imported || imp === alt)
+                return loc;
+        return undefined;
+    };
+    let lazyName = needLazy ? findLocal('gettext_lazy', 'ugettext_lazy') : undefined;
+    let eagerName = needEager ? findLocal('gettext', 'ugettext') : undefined;
+    const toImport = [];
+    const underscoreFree = !underscoreTaken(tokens, imports) && !imports.local.has('_');
+    const nameInUse = (n) => tokens.some((t) => t.type === 'name' && t.value === n) && !imports.local.has(n);
+    // `_` goes to the kind used most, unless the file already uses `_`.
+    const lazyCount = edits.filter((e) => e.lazy).length;
+    const eagerCount = edits.length - lazyCount;
+    const preferLazyUnderscore = lazyCount >= eagerCount;
+    const assign = (kind) => {
+        const imported = kind === 'lazy' ? 'gettext_lazy' : 'gettext';
+        const otherHasUnderscore = toImport.some((s) => s.endsWith(' as _'));
+        if (underscoreFree && !otherHasUnderscore && (kind === 'lazy') === preferLazyUnderscore) {
+            toImport.push(`${imported} as _`);
+            return '_';
+        }
+        if (!nameInUse(imported)) {
+            toImport.push(imported);
+            return imported;
+        }
+        toImport.push(`${imported} as django_${imported}`);
+        return `django_${imported}`;
+    };
+    if (needLazy && !lazyName)
+        lazyName = assign('lazy');
+    if (needEager && !eagerName)
+        eagerName = assign('eager');
+    const spans = edits.map((e) => ({
+        start: e.start,
+        end: e.end,
+        text: `${e.lazy ? lazyName : eagerName}(${e.inner})${e.suffix}`,
+    }));
+    let out = applySpans(src, spans);
+    if (toImport.length > 0) {
+        // Recompute against the edited text (offsets before the import block don't move,
+        // but recomputing is simpler than tracking).
+        const outTokens = (0, python_lexer_1.tokenizePython)(out);
+        const ext = existingImports(out, outTokens).extendable;
+        if (ext && `${ext.text}, ${toImport.join(', ')}`.length <= 99) {
+            out = `${out.slice(0, ext.end)}, ${toImport.join(', ')}${out.slice(ext.end)}`;
+        }
+        else {
+            const { offset, before } = importInsertPoint(out, outTokens);
+            const line = `from django.utils.translation import ${toImport.join(', ')}`;
+            if (before)
+                out = `${out.slice(0, offset)}${line}${nl}${offset === 0 && out.length && !/^\r?\n/.test(out) ? nl : ''}${out.slice(offset)}`;
+            else
+                out = `${out.slice(0, offset)}${line}${nl}${out.slice(offset)}`;
+        }
+    }
+    return out;
+}

package/dist/django/keys.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Keys for gettext messages.
+ *
+ * In a gettext project the code looks up the message itself (msgctxt +
+ * msgid), so the engine's keys are internal: they only need to be stable
+ * across runs (for the lockfile, TM and the dashboard) and unique per
+ * message. They are derived from the message: a readable slug plus a hash
+ * of context, singular and plural.
+ */
+import type { ExtractedString, GeneratedKey, GettextInfo } from '../runtime/types';
+export declare const ICU_PLURAL_ARG = "count";
+export declare function gettextMessageKey(m: Pick<GettextInfo, 'msgid' | 'msgidPlural' | 'msgctxt'>): string;
+/** Can this plural message travel as one ICU plural without its text being misread as ICU syntax? */
+export declare function icuSafe(m: Pick<GettextInfo, 'msgid' | 'msgidPlural'>): boolean;
+export declare function toIcuPlural(singular: string, plural: string): string;
+/**
+ * The engine keys (and source values to translate) for one gettext message:
+ * one key for a plain message; one ICU-plural key, or a singular and a
+ * plural key, for a plural message.
+ */
+export declare function gettextKeys(s: ExtractedString): GeneratedKey[];

package/dist/django/keys.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Keys for gettext messages.
+ *
+ * In a gettext project the code looks up the message itself (msgctxt +
+ * msgid), so the engine's keys are internal: they only need to be stable
+ * across runs (for the lockfile, TM and the dashboard) and unique per
+ * message. They are derived from the message: a readable slug plus a hash
+ * of context, singular and plural.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICU_PLURAL_ARG = void 0;
+exports.gettextMessageKey = gettextMessageKey;
+exports.icuSafe = icuSafe;
+exports.toIcuPlural = toIcuPlural;
+exports.gettextKeys = gettextKeys;
+const crypto_1 = require("crypto");
+exports.ICU_PLURAL_ARG = 'count';
+function gettextMessageKey(m) {
+    const hash = (0, crypto_1.createHash)('sha256')
+        .update(`${m.msgctxt ?? ''}\u0004${m.msgid}\u0000${m.msgidPlural ?? ''}`, 'utf8')
+        .digest('hex')
+        .slice(0, 10);
+    const words = m.msgid
+        .replace(/%\(\w+\)[sdif]|%[sdif]|\{[^{}]*\}|<[^>]*>|&[#\w]+;/g, ' ')
+        .toLowerCase()
+        .match(/[a-z0-9]+/g) ?? [];
+    const slug = words.slice(0, 5).join('_').slice(0, 40) || 'msg';
+    return `${slug}_${hash}`;
+}
+/** Can this plural message travel as one ICU plural without its text being misread as ICU syntax? */
+function icuSafe(m) {
+    const text = `${m.msgid}${m.msgidPlural ?? ''}`;
+    return !/[{}#]|''/.test(text);
+}
+function toIcuPlural(singular, plural) {
+    return `{${exports.ICU_PLURAL_ARG}, plural, one {${singular}} other {${plural}}}`;
+}
+/**
+ * The engine keys (and source values to translate) for one gettext message:
+ * one key for a plain message; one ICU-plural key, or a singular and a
+ * plural key, for a plural message.
+ */
+function gettextKeys(s) {
+    const g = s.gettext;
+    const base = gettextMessageKey(g);
+    const common = {
+        namespace: 'django',
+        extractionId: s.id,
+        parentContext: g.msgctxt,
+        extractionContext: s.context,
+    };
+    if (g.msgidPlural === undefined) {
+        return [{ ...common, key: base, value: g.msgid, gettext: { ...g, form: 'single' } }];
+    }
+    if (g.icu && icuSafe(g)) {
+        return [{ ...common, key: base, value: toIcuPlural(g.msgid, g.msgidPlural), gettext: { ...g, form: 'icu' } }];
+    }
+    return [
+        { ...common, key: `${base}_sg`, value: g.msgid, gettext: { ...g, form: 'singular' } },
+        { ...common, key: `${base}_pl`, value: g.msgidPlural, extractionId: `${s.id}_pl`, gettext: { ...g, form: 'plural' } },
+    ];
+}

package/dist/django/locale-names.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Django's two spellings of a language: the locale directory name
+ * (`to_locale()`: pt_BR, zh_Hans, sr_Latn) and the language code used in
+ * LANGUAGES / URLs (`to_language()`: pt-br, zh-hans, sr-latn).
+ */
+/** Locale directory name Django loads for a Babelize locale code. */
+export declare function djangoLocaleName(locale: string): string;
+/** Language code for Django's LANGUAGES setting. */
+export declare function djangoLanguageCode(locale: string): string;
+/** Babelize locale code for a Django locale directory name (pt_BR → pt-BR). */
+export declare function localeFromDjangoName(dir: string): string;
+/** English name of a language, for LANGUAGES ("German", "Brazilian Portuguese"). */
+export declare function languageName(locale: string): string;

package/dist/django/locale-names.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Django's two spellings of a language: the locale directory name
+ * (`to_locale()`: pt_BR, zh_Hans, sr_Latn) and the language code used in
+ * LANGUAGES / URLs (`to_language()`: pt-br, zh-hans, sr-latn).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.djangoLocaleName = djangoLocaleName;
+exports.djangoLanguageCode = djangoLanguageCode;
+exports.localeFromDjangoName = localeFromDjangoName;
+exports.languageName = languageName;
+const CHINESE = {
+    zh: { dir: 'zh_Hans', code: 'zh-hans' },
+    'zh-cn': { dir: 'zh_Hans', code: 'zh-hans' },
+    'zh-sg': { dir: 'zh_Hans', code: 'zh-hans' },
+    'zh-hans': { dir: 'zh_Hans', code: 'zh-hans' },
+    'zh-tw': { dir: 'zh_Hant', code: 'zh-hant' },
+    'zh-hk': { dir: 'zh_Hant', code: 'zh-hant' },
+    'zh-mo': { dir: 'zh_Hant', code: 'zh-hant' },
+    'zh-hant': { dir: 'zh_Hant', code: 'zh-hant' },
+};
+/** Locale directory name Django loads for a Babelize locale code. */
+function djangoLocaleName(locale) {
+    const lower = locale.toLowerCase().replace(/_/g, '-');
+    if (CHINESE[lower])
+        return CHINESE[lower].dir;
+    const [lang, ...rest] = lower.split('-');
+    if (!rest.length)
+        return lang;
+    const tail = rest.map((p) => (p.length === 2 ? p.toUpperCase() : p.length === 4 ? p[0].toUpperCase() + p.slice(1) : p));
+    return [lang, ...tail].join('_');
+}
+/** Language code for Django's LANGUAGES setting. */
+function djangoLanguageCode(locale) {
+    const lower = locale.toLowerCase().replace(/_/g, '-');
+    if (CHINESE[lower])
+        return CHINESE[lower].code;
+    return lower;
+}
+/** Babelize locale code for a Django locale directory name (pt_BR → pt-BR). */
+function localeFromDjangoName(dir) {
+    const [lang, ...rest] = dir.split('_');
+    if (lang === 'zh' && rest[0] === 'Hans')
+        return 'zh-CN';
+    if (lang === 'zh' && rest[0] === 'Hant')
+        return 'zh-TW';
+    return [lang.toLowerCase(), ...rest].join('-');
+}
+/** English name of a language, for LANGUAGES ("German", "Brazilian Portuguese"). */
+function languageName(locale) {
+    try {
+        const name = new Intl.DisplayNames(['en'], { type: 'language' }).of(locale.replace('_', '-'));
+        if (name && name.toLowerCase() !== locale.toLowerCase())
+            return name;
+    }
+    catch {
+        // fall through
+    }
+    return locale;
+}

package/dist/django/mo-file.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compile a .po catalogue to GNU .mo, the way `msgfmt` does: fuzzy and
+ * untranslated entries (and obsolete ones) are left out, so Django falls
+ * back to the msgid for them.
+ */
+export declare function compileMo(poContent: string): Buffer;

package/dist/django/mo-file.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Compile a .po catalogue to GNU .mo, the way `msgfmt` does: fuzzy and
+ * untranslated entries (and obsolete ones) are left out, so Django falls
+ * back to the msgid for them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileMo = compileMo;
+const po_file_1 = require("./po-file");
+function compileMo(poContent) {
+    const po = (0, po_file_1.parsePo)(poContent);
+    const pairs = [];
+    if (po.header)
+        pairs.push([Buffer.alloc(0), Buffer.from(po.header.msgstr[0] ?? '', 'utf8')]);
+    for (const e of po.entries) {
+        if (e.obsolete || e.flags.includes('fuzzy'))
+            continue;
+        if (e.msgstr.length === 0 || e.msgstr.some((s) => !s))
+            continue;
+        const id = (e.msgctxt !== undefined ? `${e.msgctxt}\u0004` : '') + e.msgid + (e.msgidPlural !== undefined ? `\u0000${e.msgidPlural}` : '');
+        pairs.push([Buffer.from(id, 'utf8'), Buffer.from(e.msgstr.join('\u0000'), 'utf8')]);
+    }
+    pairs.sort((a, b) => Buffer.compare(a[0], b[0]));
+    const n = pairs.length;
+    const headerSize = 28;
+    const origTable = headerSize;
+    const transTable = origTable + n * 8;
+    let offset = transTable + n * 8;
+    const origOffsets = [];
+    const transOffsets = [];
+    for (const [id] of pairs) {
+        origOffsets.push([id.length, offset]);
+        offset += id.length + 1;
+    }
+    for (const [, str] of pairs) {
+        transOffsets.push([str.length, offset]);
+        offset += str.length + 1;
+    }
+    const out = Buffer.alloc(offset);
+    out.writeUInt32LE(0x950412de, 0); // magic
+    out.writeUInt32LE(0, 4); // revision
+    out.writeUInt32LE(n, 8);
+    out.writeUInt32LE(origTable, 12);
+    out.writeUInt32LE(transTable, 16);
+    out.writeUInt32LE(0, 20); // hash table size
+    out.writeUInt32LE(offset, 24); // hash table offset (unused)
+    origOffsets.forEach(([len, off], i) => {
+        out.writeUInt32LE(len, origTable + i * 8);
+        out.writeUInt32LE(off, origTable + i * 8 + 4);
+    });
+    transOffsets.forEach(([len, off], i) => {
+        out.writeUInt32LE(len, transTable + i * 8);
+        out.writeUInt32LE(off, transTable + i * 8 + 4);
+    });
+    pairs.forEach(([id, str], i) => {
+        id.copy(out, origOffsets[i][1]);
+        str.copy(out, transOffsets[i][1]);
+    });
+    return out;
+}

package/dist/django/plural-forms.d.ts

@@ -0,0 +1,34 @@
+/**
+ * gettext plural forms.
+ *
+ * A PO file's `Plural-Forms` header says how many msgstr[n] forms a plural
+ * entry has and which one a number picks. CLDR (what translators and ICU
+ * think in) names categories instead: one, few, many, other. This module
+ * maps between the two by evaluating the gettext expression on sample
+ * numbers and asking Intl.PluralRules which category each sample is, so the
+ * mapping is right even for headers written by other tools.
+ *
+ * Expressions are evaluated by a small parser — never `eval` — because
+ * headers come from repositories Babelize doesn't control.
+ */
+export declare class PluralFormsError extends Error {
+}
+export interface PluralForms {
+    /** The header value, e.g. `nplurals=2; plural=(n != 1);` */
+    header: string;
+    nplurals: number;
+    /** msgstr index for a number. */
+    index(n: number): number;
+}
+export declare function parsePluralForms(header: string): PluralForms;
+/** Plural-Forms header for a Babelize locale code. */
+export declare function pluralFormsFor(locale: string): {
+    header: string;
+    known: boolean;
+};
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+/**
+ * CLDR category of each msgstr index for `locale` under `forms`: the
+ * category most sample integers that pick the index fall into.
+ */
+export declare function indexCategories(forms: PluralForms, locale: string): PluralCategory[];