@babelize/engine 0.0.0-stage → 0.1.2

package/dist/django/catalog.js

@@ -0,0 +1,677 @@
+"use strict";
+/**
+ * The gettext catalogue of a Django run: which messages the code uses, the
+ * existing translations in the project's .po files, and the merged .po (and,
+ * when the project commits them, .mo) files the run writes.
+ *
+ * Existing translations are the project's: a complete, non-fuzzy msgstr is
+ * never overwritten and never re-translated (it seeds the lockfile instead).
+ * Fuzzy entries are left for review. Only missing or empty entries are
+ * filled. Untouched entries are written back byte-for-byte.
+ */
+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.GettextCatalog = void 0;
+exports.formatProblem = formatProblem;
+exports.formatPoDate = formatPoDate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const hasher_1 = require("../modules/lockfile/hasher");
+const file_utils_1 = require("../utils/file-utils");
+const pseudo_markers_1 = require("../utils/pseudo-markers");
+const untranslated_1 = require("../utils/untranslated");
+const icu_message_1 = require("../utils/icu-message");
+const extract_1 = require("./extract");
+const keys_1 = require("./keys");
+const locale_names_1 = require("./locale-names");
+const plural_forms_1 = require("./plural-forms");
+const po_file_1 = require("./po-file");
+const mo_file_1 = require("./mo-file");
+function compareRefs(a, b) {
+    const fa = a.slice(0, a.lastIndexOf(':'));
+    const fb = b.slice(0, b.lastIndexOf(':'));
+    if (fa !== fb)
+        return fa < fb ? -1 : 1;
+    return Number(a.slice(a.lastIndexOf(':') + 1)) - Number(b.slice(b.lastIndexOf(':') + 1));
+}
+function sortRefs(refs) {
+    return [...new Set(refs)].sort(compareRefs);
+}
+function isComplete(e, nplurals) {
+    if (e.msgstr.length === 0 || e.msgstr.some((s) => !s))
+        return false;
+    return e.msgidPlural === undefined ? e.msgstr.length >= 1 : e.msgstr.length === nplurals;
+}
+/** Text of an ICU branch, with `#` as the count placeholder of the source. */
+function branchText(nodes, pound) {
+    let out = '';
+    for (const n of nodes) {
+        if (n.type === 'text')
+            out += n.value;
+        else if (n.type === 'pound') {
+            if (pound === null)
+                return null;
+            out += pound;
+        }
+        else
+            return null;
+    }
+    return out;
+}
+const PY_NAMED = /%\((\w+)\)[-#0 +]*\d*(?:\.\d+)?[sdiouxXeEfFgGcr]/g;
+const PY_POSITIONAL = /%(?!\()[-#0 +]*\d*(?:\.\d+)?[sdiouxXeEfFgGcr]/g;
+const BRACE_NAMED = /\{([A-Za-z_]\w*)(?:[.[][^{}]*)?(?:![rsa])?(?::[^{}]*)?\}/g;
+const BRACE_POSITIONAL = /\{(\d*)(?:![rsa])?(?::[^{}]*)?\}/g;
+function placeholders(text, flags) {
+    const t = text.replace(/%%/g, '').replace(/\{\{|\}\}/g, '');
+    if (flags.includes('python-format')) {
+        return {
+            named: [...t.matchAll(PY_NAMED)].map((m) => m[1]).sort(),
+            positional: [...t.matchAll(PY_POSITIONAL)].map((m) => m[0].slice(-1)),
+        };
+    }
+    if (flags.includes('python-brace-format')) {
+        return {
+            named: [...t.matchAll(BRACE_NAMED)].map((m) => m[1]).sort(),
+            positional: [...t.matchAll(BRACE_POSITIONAL)].map((m) => m[1] || '{}'),
+        };
+    }
+    return { named: [], positional: [] };
+}
+/**
+ * Why a translated form would fail `msgfmt --check-format` (and break
+ * `compilemessages`), or null if it's fine.
+ */
+function formatProblem(source, translated, flags, allowDroppingCount, union) {
+    if (!flags.includes('python-format') && !flags.includes('python-brace-format'))
+        return null;
+    const want = placeholders(source, flags);
+    const got = placeholders(translated, flags);
+    const allowed = new Set(placeholders(union ?? source, flags).named);
+    const invented = got.named.filter((n) => !allowed.has(n));
+    if (invented.length)
+        return `adds placeholder ${invented.map((n) => `%(${n})s`).join(', ')} that is not in the source`;
+    const missing = want.named.filter((n) => !got.named.includes(n));
+    if (missing.length && !allowDroppingCount)
+        return `drops placeholder ${missing.map((n) => `%(${n})s`).join(', ')}`;
+    if (got.positional.join(',') !== want.positional.join(',') && !(allowDroppingCount && got.positional.length === 0)) {
+        return `positional placeholders differ (source has ${want.positional.length}, translation has ${got.positional.length})`;
+    }
+    return null;
+}
+class GettextCatalog {
+    constructor(workspace, entries) {
+        this.workspace = workspace;
+        this.byKey = new Map();
+        this.states = new Map();
+        this.entries = entries;
+        for (const entry of entries) {
+            for (const [form, key] of Object.entries(entry.keys)) {
+                if (key)
+                    this.byKey.set(key, { entry, form: form });
+            }
+        }
+    }
+    /** Build the run's catalogue and read the existing .po file of every target locale. */
+    static async create(workspace, strings, keys, targetLocales) {
+        const byMessage = new Map();
+        for (const s of strings) {
+            const g = s.gettext;
+            if (!g)
+                continue;
+            const k = (0, po_file_1.entryKey)(g.msgctxt, g.msgid);
+            let entry = byMessage.get(k);
+            if (!entry) {
+                entry = { message: { ...g, flags: [...g.flags], comments: [...g.comments] }, references: [], keys: {} };
+                byMessage.set(k, entry);
+            }
+            else {
+                // The same msgid used as plural somewhere wins (gettext has one entry per msgid).
+                if (g.msgidPlural !== undefined && entry.message.msgidPlural === undefined)
+                    entry.message = { ...entry.message, msgidPlural: g.msgidPlural, icu: g.icu };
+                for (const f of g.flags)
+                    if (!entry.message.flags.includes(f))
+                        entry.message.flags.push(f);
+                for (const c of g.comments)
+                    if (!entry.message.comments.includes(c))
+                        entry.message.comments.push(c);
+                entry.message.wrapped = entry.message.wrapped && g.wrapped;
+            }
+            entry.references.push(`${s.file}:${s.line}`);
+        }
+        for (const key of keys) {
+            if (!key.gettext)
+                continue;
+            const entry = byMessage.get((0, po_file_1.entryKey)(key.gettext.msgctxt, key.gettext.msgid));
+            if (!entry)
+                continue;
+            // A key for the singular-only variant of a message that is plural elsewhere is dropped.
+            if ((key.gettext.msgidPlural ?? null) !== (entry.message.msgidPlural ?? null))
+                continue;
+            const form = key.gettext.form;
+            entry.keys[form === 'single' ? 'single' : form] = key.key;
+        }
+        const entries = [...byMessage.values()].filter((e) => Object.values(e.keys).some(Boolean));
+        for (const e of entries)
+            e.references = sortRefs(e.references);
+        entries.sort((a, b) => compareRefs(a.references[0] ?? '', b.references[0] ?? ''));
+        const catalog = new GettextCatalog(workspace, entries);
+        for (const locale of targetLocales)
+            await catalog.loadLocale(locale);
+        return catalog;
+    }
+    /** The Django project's name: the package of its settings module (from manage.py). */
+    projectName() {
+        try {
+            const manage = fs.readFileSync(path.join(this.workspace.path, this.workspace.djangoRoot ?? '.', 'manage.py'), 'utf8');
+            const m = /DJANGO_SETTINGS_MODULE['"]\s*,\s*['"]([\w]+)/.exec(manage);
+            if (m)
+                return m[1];
+        }
+        catch {
+            // no manage.py
+        }
+        return 'django-project';
+    }
+    async loadLocale(locale) {
+        const existing = this.states.get(locale);
+        if (existing)
+            return existing;
+        const { file, relativeFile } = (0, file_utils_1.localeFilePath)(this.workspace.path, this.workspace.publicDir, 'po', locale);
+        let content = null;
+        let parsed = null;
+        try {
+            content = await fs.promises.readFile(file, 'utf8');
+        }
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw err;
+        }
+        if (content !== null) {
+            try {
+                parsed = (0, po_file_1.parsePo)(content);
+            }
+            catch (err) {
+                // Never overwrite a catalogue we can't read correctly.
+                throw new Error(`Could not parse ${relativeFile}: ${err.message}`);
+            }
+        }
+        let forms = null;
+        let guessed = false;
+        const header = (0, po_file_1.getHeaderField)(parsed?.header, 'Plural-Forms');
+        if (header) {
+            try {
+                forms = (0, plural_forms_1.parsePluralForms)(header);
+            }
+            catch {
+                forms = null;
+            }
+        }
+        if (!forms) {
+            const fallback = (0, plural_forms_1.pluralFormsFor)(locale);
+            forms = (0, plural_forms_1.parsePluralForms)(fallback.header);
+            guessed = !fallback.known;
+        }
+        const state = {
+            locale, file, relativeFile, existing: parsed, existingContent: content, forms,
+            categories: (0, plural_forms_1.indexCategories)(forms, locale), guessedForms: guessed,
+        };
+        this.states.set(locale, state);
+        return state;
+    }
+    existingEntry(state, entry) {
+        const k = (0, po_file_1.entryKey)(entry.message.msgctxt, entry.message.msgid);
+        return state.existing?.entries.find((e) => !e.obsolete && (0, po_file_1.entryKey)(e.msgctxt, e.msgid) === k);
+    }
+    /**
+     * Translations already in the .po files, by engine key: they count as done
+     * (seeded into the lockfile) so they are neither re-translated nor billed.
+     */
+    existingTranslations(locale) {
+        const state = this.states.get(locale);
+        const out = {};
+        if (!state?.existing)
+            return out;
+        for (const entry of this.entries) {
+            const e = this.existingEntry(state, entry);
+            if (!e || e.flags.includes('fuzzy'))
+                continue;
+            if ((e.msgidPlural ?? null) !== (entry.message.msgidPlural ?? null))
+                continue;
+            if (!isComplete(e, state.forms.nplurals))
+                continue;
+            if (entry.keys.single)
+                out[entry.keys.single] = e.msgstr[0];
+            if (entry.keys.singular || entry.keys.plural) {
+                const one = state.categories.indexOf('one');
+                const other = state.categories.lastIndexOf('other');
+                const pl = e.msgstr[other !== -1 ? other : e.msgstr.length - 1];
+                if (entry.keys.singular)
+                    out[entry.keys.singular] = e.msgstr[one !== -1 ? one : 0];
+                if (entry.keys.plural)
+                    out[entry.keys.plural] = pl;
+            }
+            if (entry.keys.icu) {
+                if (e.msgstr.some((f) => /[{}#]/.test(f)))
+                    continue;
+                const branches = [];
+                const seen = new Set();
+                state.categories.forEach((cat, i) => {
+                    if (seen.has(cat))
+                        return;
+                    seen.add(cat);
+                    branches.push(`${cat} {${e.msgstr[i]}}`);
+                });
+                if (!seen.has('other'))
+                    branches.push(`other {${e.msgstr[e.msgstr.length - 1]}}`);
+                out[entry.keys.icu] = `{${keys_1.ICU_PLURAL_ARG}, plural, ${branches.join(' ')}}`;
+            }
+        }
+        return out;
+    }
+    /**
+     * For each ICU-plural key: the placeholder that shows the count in its
+     * branches (`%(count)d`, or a lone `%d`). A plain-text translator gets a
+     * number of each plural category in its place, so every gettext form is
+     * inflected for its own numbers.
+     */
+    pluralValuePlaceholders() {
+        const out = {};
+        for (const entry of this.entries) {
+            const m = entry.message;
+            if (!entry.keys.icu || m.msgidPlural === undefined || !m.flags.includes('python-format'))
+                continue;
+            const text = m.msgidPlural.replace(/%%/g, '');
+            const named = [...text.matchAll(PY_NAMED)];
+            if (named.length > 0) {
+                if (new Set(named.map((x) => x[1])).size === 1)
+                    out[entry.keys.icu] = named[0][0];
+                continue;
+            }
+            const positional = [...text.matchAll(PY_POSITIONAL)];
+            if (positional.length === 1)
+                out[entry.keys.icu] = positional[0][0];
+        }
+        return out;
+    }
+    /** Put existing .po translations into the lockfile (they win over its cached values). */
+    seedLockfile(lockfile, flatKeys) {
+        const next = JSON.parse(JSON.stringify(lockfile));
+        const now = new Date().toISOString();
+        for (const state of this.states.values()) {
+            for (const [key, value] of Object.entries(this.existingTranslations(state.locale))) {
+                const source = flatKeys[key];
+                if (source === undefined)
+                    continue;
+                const hash = (0, hasher_1.hashSourceString)(source);
+                const entry = next.keys[key] ?? { sourceHash: hash, translatedAt: now, languages: {}, metadata: {} };
+                if (entry.sourceHash !== hash) {
+                    entry.sourceHash = hash;
+                    entry.languages = {};
+                    entry.metadata = {};
+                }
+                // A value Babelize didn't write (a translator edited the .po file) is
+                // the project's own: glossary edits must not re-translate it.
+                if (entry.languages[state.locale] !== value) {
+                    entry.metadata = { ...(entry.metadata ?? {}), [state.locale]: { external: true } };
+                }
+                entry.languages[state.locale] = value;
+                if (entry.metadata?.[state.locale]?.pseudo && !(0, pseudo_markers_1.isPseudoLocalized)(value))
+                    delete entry.metadata[state.locale];
+                next.keys[key] = entry;
+            }
+        }
+        return next;
+    }
+    /**
+     * msgstr forms for an entry from the run's translations, or a reason it
+     * can't have them yet (null when simply untranslated).
+     */
+    formsFor(entry, locale, values) {
+        const state = this.states.get(locale);
+        const m = entry.message;
+        if (entry.keys.single) {
+            const v = values[entry.keys.single];
+            if (!v)
+                return null;
+            const problem = formatProblem(m.msgid, v, m.flags, false);
+            return problem ? { problem, key: entry.keys.single } : { forms: [v] };
+        }
+        const byCategory = new Map();
+        let failKey = entry.keys.icu ?? entry.keys.plural;
+        if (entry.keys.icu) {
+            const v = values[entry.keys.icu];
+            if (!v)
+                return null;
+            let nodes;
+            try {
+                nodes = (0, icu_message_1.parseIcu)(v);
+            }
+            catch (err) {
+                return { problem: `translation is not a valid ICU plural: ${err.message}`, key: entry.keys.icu };
+            }
+            // One plural; text around it belongs to every form ("Total: {count, plural, …}").
+            const pluralIdx = nodes.findIndex((n) => n.type === 'plural');
+            const plural = nodes[pluralIdx];
+            const outside = nodes.filter((_, i) => i !== pluralIdx);
+            if (!plural || outside.some((n) => n.type !== 'text')) {
+                return { problem: 'translation is not a single ICU plural', key: entry.keys.icu };
+            }
+            const prefix = nodes.slice(0, pluralIdx).map((n) => (n.type === 'text' ? n.value : '')).join('');
+            const suffix = nodes.slice(pluralIdx + 1).map((n) => (n.type === 'text' ? n.value : '')).join('');
+            const countNames = placeholders(m.msgidPlural ?? '', m.flags).named;
+            const pound = countNames.length === 1 ? `%(${countNames[0]})s` : null;
+            for (const [cat, branch] of Object.entries(plural.options)) {
+                const text = branchText(branch, pound);
+                if (text === null)
+                    return { problem: `plural branch "${cat}" uses ICU syntax gettext can't express`, key: entry.keys.icu };
+                byCategory.set(cat === '=1' && !plural.options.one ? 'one' : cat, `${prefix}${text}${suffix}`);
+            }
+        }
+        else {
+            const sg = values[entry.keys.singular];
+            const pl = values[entry.keys.plural];
+            if (!sg || !pl)
+                return null;
+            byCategory.set('one', sg);
+            byCategory.set('other', pl);
+        }
+        const forms = [];
+        for (const cat of state.categories) {
+            const text = byCategory.get(cat) ?? byCategory.get('other');
+            if (!text)
+                return null;
+            const isOne = cat === 'one' || cat === 'zero' || cat === 'two';
+            const src = cat === 'one' ? m.msgid : m.msgidPlural;
+            if (!entry.keys.icu)
+                failKey = cat === 'one' ? entry.keys.singular : entry.keys.plural;
+            const problem = formatProblem(src, text, m.flags, isOne, `${m.msgid} ${m.msgidPlural}`);
+            if (problem)
+                return { problem: `${cat} form ${problem}`, key: failKey };
+            forms.push(text);
+        }
+        return { forms };
+    }
+    /**
+     * Check every fresh translation can go into a .po file that compiles:
+     * placeholders must match the source (msgfmt --check-format), plurals must
+     * map onto the language's forms. Bad values are removed and reported as
+     * failures (and retried next run) — never shipped, never replaced by the
+     * source text.
+     */
+    validate(translation, sourceValues) {
+        for (const localeFile of translation.locales) {
+            const state = this.states.get(localeFile.locale);
+            if (!state)
+                continue;
+            const values = localeFile.data;
+            const otherScript = !(0, untranslated_1.isLatinScript)(localeFile.locale);
+            for (const entry of this.entries) {
+                const keys = Object.values(entry.keys).filter((k) => !!k && typeof values[k] === 'string');
+                if (!keys.length)
+                    continue;
+                // Into a non-Latin-script language, English text that came back unchanged
+                // was not translated: report it (and retry next run) rather than writing
+                // it into the catalogue as if it were a translation.
+                const unchanged = otherScript ? keys.find((k) => values[k] === sourceValues[k] && (0, untranslated_1.hasWords)(sourceValues[k])) : undefined;
+                if (unchanged) {
+                    for (const k of keys)
+                        delete values[k];
+                    (translation.failures ?? (translation.failures = [])).push({
+                        locale: localeFile.locale,
+                        key: unchanged,
+                        source: sourceValues[unchanged],
+                        reason: 'untranslated',
+                        retryable: true,
+                        message: `Returned unchanged instead of translated into ${localeFile.locale}`,
+                    });
+                    continue;
+                }
+                const r = this.formsFor(entry, localeFile.locale, values);
+                if (r && 'problem' in r) {
+                    for (const k of keys)
+                        delete values[k];
+                    (translation.failures ?? (translation.failures = [])).push({
+                        locale: localeFile.locale,
+                        key: r.key,
+                        source: sourceValues[r.key] ?? entry.message.msgid,
+                        reason: 'placeholder_lost',
+                        retryable: true,
+                        message: `Placeholder problem: ${r.problem}`,
+                    });
+                }
+            }
+        }
+    }
+    /** Point references at where strings are after injection (lines move when imports/tags are added). */
+    refreshReferences(injection) {
+        const fresh = new Map();
+        const files = new Set();
+        for (const f of injection.modifiedFiles) {
+            const analysis = (0, extract_1.analyzeDjangoFile)(f.modifiedContent, f.file);
+            if (!analysis)
+                continue;
+            files.add(f.file);
+            for (const finding of analysis.findings) {
+                const k = (0, po_file_1.entryKey)(finding.message.msgctxt, finding.message.msgid);
+                fresh.set(k, [...(fresh.get(k) ?? []), `${f.file}:${finding.line}`]);
+            }
+        }
+        if (!files.size)
+            return;
+        for (const entry of this.entries) {
+            const kept = entry.references.filter((r) => !files.has(r.slice(0, r.lastIndexOf(':'))));
+            const added = fresh.get((0, po_file_1.entryKey)(entry.message.msgctxt, entry.message.msgid)) ?? [];
+            entry.references = sortRefs([...kept, ...added]);
+        }
+    }
+    /**
+     * Merge the run's translations into each target locale's .po file.
+     * Returns LocaleFiles carrying the exact content (and .mo when the project
+     * commits compiled catalogues); writes them unless `dryRun`.
+     */
+    async write(targetLocales, valuesByLocale, options) {
+        const notes = [];
+        const locales = [];
+        const now = options.now ?? new Date();
+        const stamp = formatPoDate(now);
+        let fuzzyKept = 0;
+        const approximated = [];
+        for (const locale of targetLocales) {
+            const state = await this.loadLocale(locale);
+            const values = valuesByLocale[locale] ?? {};
+            const file = state.existing ?? { entries: [], newline: '\n' };
+            let changed = !state.existing;
+            const insertAt = (() => {
+                let idx = file.entries.length;
+                while (idx > 0 && file.entries[idx - 1].obsolete)
+                    idx--;
+                return idx;
+            })();
+            const added = [];
+            let plainPluralApprox = 0;
+            for (const entry of this.entries) {
+                const m = entry.message;
+                const r = this.formsFor(entry, locale, values);
+                const forms = r && 'forms' in r ? r.forms : null;
+                const empty = m.msgidPlural !== undefined ? Array(state.forms.nplurals).fill('') : [''];
+                if (forms && !entry.keys.icu && m.msgidPlural !== undefined && state.categories.some((c) => c !== 'one' && c !== 'other'))
+                    plainPluralApprox++;
+                const e = this.existingEntry(state, entry);
+                if (e) {
+                    const samePlural = (e.msgidPlural ?? null) === (m.msgidPlural ?? null);
+                    const fuzzy = e.flags.includes('fuzzy');
+                    const stalePseudo = !options.pseudo && e.msgstr.some((s) => (0, pseudo_markers_1.isPseudoLocalized)(s));
+                    if (samePlural && !fuzzy && !stalePseudo && isComplete(e, state.forms.nplurals))
+                        continue; // theirs
+                    if (samePlural && fuzzy && e.msgstr.some(Boolean)) {
+                        fuzzyKept++;
+                        continue;
+                    }
+                    const nextMsgstr = forms ?? (samePlural && !stalePseudo ? padForms(e.msgstr, empty.length) : empty);
+                    const nextFlags = mergeFlags(forms ? e.flags.filter((f) => f !== 'fuzzy') : e.flags, m.flags);
+                    const nextRefs = entry.references;
+                    const differs = JSON.stringify(nextMsgstr) !== JSON.stringify(e.msgstr) ||
+                        (e.msgidPlural ?? null) !== (m.msgidPlural ?? null) ||
+                        nextFlags.join() !== e.flags.join() ||
+                        (forms !== null && nextRefs.join() !== e.references.join());
+                    if (!differs)
+                        continue;
+                    e.msgstr = nextMsgstr;
+                    e.msgidPlural = m.msgidPlural;
+                    e.flags = nextFlags;
+                    if (forms)
+                        e.references = nextRefs;
+                    if (m.comments.length)
+                        e.extractedComments = m.comments;
+                    e.dirty = true;
+                    changed = true;
+                    continue;
+                }
+                added.push({
+                    translatorComments: [],
+                    extractedComments: m.comments,
+                    references: entry.references,
+                    flags: [...m.flags],
+                    previous: [],
+                    msgctxt: m.msgctxt,
+                    msgid: m.msgid,
+                    msgidPlural: m.msgidPlural,
+                    msgstr: forms ?? empty,
+                    obsolete: false,
+                    dirty: true,
+                });
+                changed = true;
+            }
+            if (plainPluralApprox > 0)
+                approximated.push(`${locale} (${plainPluralApprox})`);
+            file.entries.splice(insertAt, 0, ...added);
+            const langName = (0, locale_names_1.languageName)(locale);
+            if (!file.header) {
+                file.header = {
+                    translatorComments: [`${langName} translations.`, 'Generated by Babelize (https://babelize.co).', ''],
+                    extractedComments: [], references: [], flags: [], previous: [], msgid: '', msgstr: [''], obsolete: false, dirty: true,
+                };
+                (0, po_file_1.setHeaderFields)(file.header, [
+                    ['Project-Id-Version', options.projectName ?? this.projectName()],
+                    ['Report-Msgid-Bugs-To', ''],
+                    ['POT-Creation-Date', stamp],
+                    ['PO-Revision-Date', stamp],
+                    ['Last-Translator', 'Babelize'],
+                    ['Language-Team', langName],
+                    ['Language', (0, locale_names_1.djangoLocaleName)(locale)],
+                    ['MIME-Version', '1.0'],
+                    ['Content-Type', 'text/plain; charset=UTF-8'],
+                    ['Content-Transfer-Encoding', '8bit'],
+                    ['Plural-Forms', state.forms.header],
+                    ['X-Generator', 'Babelize'],
+                ]);
+            }
+            else {
+                const h = file.header;
+                const updates = [];
+                if (!(0, po_file_1.getHeaderField)(h, 'Language'))
+                    updates.push(['Language', (0, locale_names_1.djangoLocaleName)(locale)]);
+                if (!(0, po_file_1.getHeaderField)(h, 'Plural-Forms'))
+                    updates.push(['Plural-Forms', state.forms.header]);
+                const ct = (0, po_file_1.getHeaderField)(h, 'Content-Type');
+                if (!ct || /charset=CHARSET/i.test(ct))
+                    updates.push(['Content-Type', 'text/plain; charset=UTF-8']);
+                if (!(0, po_file_1.getHeaderField)(h, 'Content-Transfer-Encoding'))
+                    updates.push(['Content-Transfer-Encoding', '8bit']);
+                if (!(0, po_file_1.getHeaderField)(h, 'MIME-Version'))
+                    updates.push(['MIME-Version', '1.0']);
+                if (updates.length && (0, po_file_1.setHeaderFields)(h, updates))
+                    changed = true;
+                if (changed)
+                    (0, po_file_1.setHeaderFields)(h, [['PO-Revision-Date', stamp], ['X-Generator', 'Babelize']]);
+            }
+            if (state.guessedForms) {
+                notes.push(`Plural forms for ${locale} are not known to Babelize; used "${state.forms.header}". Check the Plural-Forms header in ${state.relativeFile}.`);
+            }
+            const content = changed || state.existingContent === null ? (0, po_file_1.serializePo)(file) : state.existingContent;
+            const localeFile = {
+                locale,
+                path: state.relativeFile,
+                data: values,
+                isNew: state.existingContent === null,
+                content,
+            };
+            // Projects that commit compiled catalogues get their .mo kept in sync —
+            // a stale .mo would shadow the new translations.
+            const moPath = state.file.replace(/\.po$/, '.mo');
+            if (fs.existsSync(moPath) && content !== state.existingContent) {
+                const mo = (0, mo_file_1.compileMo)(content);
+                localeFile.extraFiles = [{ path: state.relativeFile.replace(/\.po$/, '.mo'), content: mo.toString('base64'), encoding: 'base64' }];
+                if (!options.dryRun)
+                    await fs.promises.writeFile(moPath, mo);
+            }
+            if (!options.dryRun && content !== state.existingContent) {
+                await fs.promises.mkdir(path.dirname(state.file), { recursive: true });
+                await fs.promises.writeFile(state.file, content);
+            }
+            locales.push(localeFile);
+        }
+        if (fuzzyKept > 0) {
+            notes.push(`${fuzzyKept} fuzzy translation(s) in your .po files were left for review — Django ignores fuzzy entries until the flag is removed.`);
+        }
+        if (approximated.length > 0) {
+            notes.push(`Plural messages in ${approximated.join(', ')} use the translated plural text for every non-singular form: ` +
+                'this translator translates singular and plural separately and can\'t produce each grammatical form these languages have. ' +
+                'Review them, or translate with an AI provider for full plural forms.');
+        }
+        const compiled = locales.some((l) => l.extraFiles?.length);
+        if (!compiled && locales.length > 0) {
+            notes.push('Run `python manage.py compilemessages` to compile the .po files (Django loads the compiled .mo files).');
+        }
+        return { locales, notes };
+    }
+}
+exports.GettextCatalog = GettextCatalog;
+function padForms(forms, n) {
+    return Array.from({ length: n }, (_, i) => forms[i] ?? '');
+}
+function mergeFlags(existing, wanted) {
+    const out = [...existing];
+    for (const f of wanted)
+        if (!out.includes(f))
+            out.push(f);
+    return out;
+}
+/** PO date format: 2026-10-10 14:03+0000 */
+function formatPoDate(d) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())} ${p(d.getUTCHours())}:${p(d.getUTCMinutes())}+0000`;
+}