@babelize/engine 0.0.0-stage → 0.1.2

package/dist/django/plural-forms.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluralFormsError = void 0;
+exports.parsePluralForms = parsePluralForms;
+exports.pluralFormsFor = pluralFormsFor;
+exports.indexCategories = indexCategories;
+/** Plural-Forms for common languages (GNU gettext / Django conventions). */
+const PLURAL_FORMS = {
+    // One form
+    ja: 'nplurals=1; plural=0;', ko: 'nplurals=1; plural=0;', zh: 'nplurals=1; plural=0;', vi: 'nplurals=1; plural=0;',
+    th: 'nplurals=1; plural=0;', id: 'nplurals=1; plural=0;', ms: 'nplurals=1; plural=0;', km: 'nplurals=1; plural=0;',
+    lo: 'nplurals=1; plural=0;', my: 'nplurals=1; plural=0;', jv: 'nplurals=1; plural=0;', yo: 'nplurals=1; plural=0;',
+    ig: 'nplurals=1; plural=0;', bo: 'nplurals=1; plural=0;', dz: 'nplurals=1; plural=0;', su: 'nplurals=1; plural=0;',
+    // Two forms, singular for 0 and 1
+    fr: 'nplurals=2; plural=(n > 1);', 'pt-BR': 'nplurals=2; plural=(n > 1);', tr: 'nplurals=2; plural=(n > 1);',
+    fa: 'nplurals=2; plural=(n > 1);', am: 'nplurals=2; plural=(n > 1);', ti: 'nplurals=2; plural=(n > 1);',
+    ln: 'nplurals=2; plural=(n > 1);', mg: 'nplurals=2; plural=(n > 1);', oc: 'nplurals=2; plural=(n > 1);',
+    fil: 'nplurals=2; plural=(n > 1);', tl: 'nplurals=2; plural=(n > 1);', uz: 'nplurals=2; plural=(n > 1);',
+    // Special two-form rules
+    is: 'nplurals=2; plural=(n % 10 != 1 || n % 100 == 11);',
+    mk: 'nplurals=2; plural=(n % 10 == 1 && n % 100 != 11) ? 0 : 1;',
+    // Three or more forms
+    ru: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    uk: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    be: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    sr: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    hr: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    bs: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    pl: 'nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    cs: 'nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;',
+    sk: 'nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;',
+    lt: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2);',
+    lv: 'nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2);',
+    ro: 'nplurals=3; plural=(n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2);',
+    sl: 'nplurals=4; plural=(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3);',
+    ga: 'nplurals=5; plural=(n==1 ? 0 : n==2 ? 1 : n<7 ? 2 : n<11 ? 3 : 4);',
+    cy: 'nplurals=4; plural=(n==1) ? 0 : (n==2) ? 1 : (n != 8 && n != 11) ? 2 : 3;',
+    mt: 'nplurals=4; plural=(n==1 ? 0 : n==0 || (n%100>1 && n%100<11) ? 1 : (n%100>10 && n%100<20) ? 2 : 3);',
+    ar: 'nplurals=6; plural=(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 ? 4 : 5);',
+    he: 'nplurals=3; plural=(n==1 ? 0 : n==2 ? 1 : 2);',
+    gd: 'nplurals=4; plural=(n==1 || n==11) ? 0 : (n==2 || n==12) ? 1 : (n > 2 && n < 20) ? 2 : 3;',
+};
+const DEFAULT_TWO = 'nplurals=2; plural=(n != 1);';
+const BINARY_PRECEDENCE = {
+    '||': 1, '&&': 2, '==': 3, '!=': 3, '<': 4, '>': 4, '<=': 4, '>=': 4, '+': 5, '-': 5, '*': 6, '/': 6, '%': 6,
+};
+class PluralFormsError extends Error {
+}
+exports.PluralFormsError = PluralFormsError;
+function parseExpression(src) {
+    const tokens = src.match(/\d+|n|\|\||&&|==|!=|<=|>=|[-+*/%<>!?:()]/g) ?? [];
+    if (tokens.join('') !== src.replace(/\s+/g, ''))
+        throw new PluralFormsError(`Unsupported plural expression: ${src}`);
+    let pos = 0;
+    const peek = () => tokens[pos];
+    const take = (expect) => {
+        const t = tokens[pos++];
+        if (expect !== undefined && t !== expect)
+            throw new PluralFormsError(`Expected ${expect} in plural expression`);
+        return t;
+    };
+    const primary = () => {
+        const t = take();
+        if (t === undefined)
+            throw new PluralFormsError('Unexpected end of plural expression');
+        if (t === 'n')
+            return { t: 'n' };
+        if (/^\d+$/.test(t))
+            return { t: 'num', v: Number(t) };
+        if (t === '(') {
+            const e = conditional();
+            take(')');
+            return e;
+        }
+        if (t === '!' || t === '-')
+            return { t: 'un', op: t, a: primary() };
+        throw new PluralFormsError(`Unexpected ${t} in plural expression`);
+    };
+    const binary = (minPrec) => {
+        let left = primary();
+        for (;;) {
+            const op = peek();
+            const prec = op !== undefined ? BINARY_PRECEDENCE[op] : undefined;
+            if (prec === undefined || prec < minPrec)
+                return left;
+            take();
+            left = { t: 'bin', op, a: left, b: binary(prec + 1) };
+        }
+    };
+    const conditional = () => {
+        const c = binary(1);
+        if (peek() !== '?')
+            return c;
+        take('?');
+        const a = conditional();
+        take(':');
+        const b = conditional();
+        return { t: 'cond', c, a, b };
+    };
+    const tree = conditional();
+    if (pos !== tokens.length)
+        throw new PluralFormsError(`Trailing tokens in plural expression: ${src}`);
+    return tree;
+}
+function evaluate(node, n) {
+    switch (node.t) {
+        case 'n': return n;
+        case 'num': return node.v;
+        case 'un': return node.op === '!' ? (evaluate(node.a, n) ? 0 : 1) : -evaluate(node.a, n);
+        case 'cond': return evaluate(node.c, n) ? evaluate(node.a, n) : evaluate(node.b, n);
+        case 'bin': {
+            const a = evaluate(node.a, n);
+            const b = evaluate(node.b, n);
+            switch (node.op) {
+                case '||': return a || b ? 1 : 0;
+                case '&&': return a && b ? 1 : 0;
+                case '==': return a === b ? 1 : 0;
+                case '!=': return a !== b ? 1 : 0;
+                case '<': return a < b ? 1 : 0;
+                case '>': return a > b ? 1 : 0;
+                case '<=': return a <= b ? 1 : 0;
+                case '>=': return a >= b ? 1 : 0;
+                case '+': return a + b;
+                case '-': return a - b;
+                case '*': return a * b;
+                case '/': return b === 0 ? 0 : Math.trunc(a / b);
+                case '%': return b === 0 ? 0 : a % b;
+            }
+        }
+    }
+    return 0;
+}
+function parsePluralForms(header) {
+    const np = /nplurals\s*=\s*(\d+)/.exec(header);
+    const pl = /plural\s*=\s*([^;]+);?/.exec(header);
+    if (!np || !pl)
+        throw new PluralFormsError(`Invalid Plural-Forms header: ${header}`);
+    const nplurals = Number(np[1]);
+    if (nplurals < 1 || nplurals > 10)
+        throw new PluralFormsError(`Unsupported nplurals: ${nplurals}`);
+    const tree = parseExpression(pl[1].trim());
+    return {
+        header: header.trim(),
+        nplurals,
+        index: (n) => {
+            const i = evaluate(tree, n);
+            return i >= 0 && i < nplurals ? i : 0;
+        },
+    };
+}
+function baseLanguage(locale) {
+    return locale.split(/[-_]/)[0].toLowerCase();
+}
+/** Plural-Forms header for a Babelize locale code. */
+function pluralFormsFor(locale) {
+    const exact = Object.keys(PLURAL_FORMS).find((k) => k.toLowerCase() === locale.toLowerCase().replace('_', '-'));
+    if (exact)
+        return { header: PLURAL_FORMS[exact], known: true };
+    const base = baseLanguage(locale);
+    if (PLURAL_FORMS[base])
+        return { header: PLURAL_FORMS[base], known: true };
+    // Derive the common shapes from CLDR when the language isn't in the table.
+    try {
+        const rules = new Intl.PluralRules(locale);
+        const cats = rules.resolvedOptions().pluralCategories;
+        if (cats.length === 1)
+            return { header: 'nplurals=1; plural=0;', known: true };
+        if (cats.length === 2 && cats.includes('one')) {
+            const zeroIsOne = rules.select(0) === 'one';
+            const onlyOne = [2, 11, 21, 101].every((n) => rules.select(n) === 'other');
+            if (onlyOne)
+                return { header: zeroIsOne ? 'nplurals=2; plural=(n > 1);' : DEFAULT_TWO, known: true };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { header: DEFAULT_TWO, known: false };
+}
+/**
+ * CLDR category of each msgstr index for `locale` under `forms`: the
+ * category most sample integers that pick the index fall into.
+ */
+function indexCategories(forms, locale) {
+    let rules;
+    try {
+        rules = new Intl.PluralRules(locale);
+    }
+    catch {
+        rules = new Intl.PluralRules('en');
+    }
+    const votes = Array.from({ length: forms.nplurals }, () => new Map());
+    for (let n = 0; n <= 1000; n++) {
+        const i = forms.index(n);
+        const cat = rules.select(n);
+        votes[i].set(cat, (votes[i].get(cat) ?? 0) + (n <= 200 ? 2 : 1));
+    }
+    return votes.map((v, i) => {
+        if (v.size === 0)
+            return i === forms.nplurals - 1 ? 'other' : 'other';
+        return [...v.entries()].sort((a, b) => b[1] - a[1])[0][0];
+    });
+}

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

@@ -0,0 +1,38 @@
+/**
+ * PO file reading and writing that preserves what it doesn't change.
+ *
+ * Entries Babelize doesn't touch are written back exactly as they were read
+ * (comments, references, flags, wrapping, obsolete `#~` entries), so merging
+ * into a hand-maintained catalogue produces a minimal diff. Changed and new
+ * entries are serialized the way GNU gettext tools write them.
+ */
+export interface PoEntry {
+    translatorComments: string[];
+    extractedComments: string[];
+    references: string[];
+    flags: string[];
+    /** `#|` previous-msgid lines, kept verbatim (without the `#| ` prefix). */
+    previous: string[];
+    msgctxt?: string;
+    msgid: string;
+    msgidPlural?: string;
+    msgstr: string[];
+    obsolete: boolean;
+    /** Original text of the entry; written back verbatim unless `dirty`. */
+    raw?: string;
+    dirty: boolean;
+}
+export interface PoFile {
+    /** Header entry (msgid ""), if present. */
+    header?: PoEntry;
+    entries: PoEntry[];
+    newline: '\n' | '\r\n';
+}
+export declare function entryKey(msgctxt: string | undefined, msgid: string): string;
+export declare function parsePo(content: string): PoFile;
+export declare function serializeEntry(e: PoEntry): string[];
+export declare function serializePo(file: PoFile): string;
+export declare function headerFields(header: PoEntry | undefined): Array<[string, string]>;
+export declare function getHeaderField(header: PoEntry | undefined, name: string): string | undefined;
+/** Set header fields (in place, keeping order; new fields are appended). */
+export declare function setHeaderFields(header: PoEntry, updates: Array<[string, string]>): boolean;

package/dist/django/po-file.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * PO file reading and writing that preserves what it doesn't change.
+ *
+ * Entries Babelize doesn't touch are written back exactly as they were read
+ * (comments, references, flags, wrapping, obsolete `#~` entries), so merging
+ * into a hand-maintained catalogue produces a minimal diff. Changed and new
+ * entries are serialized the way GNU gettext tools write them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entryKey = entryKey;
+exports.parsePo = parsePo;
+exports.serializeEntry = serializeEntry;
+exports.serializePo = serializePo;
+exports.headerFields = headerFields;
+exports.getHeaderField = getHeaderField;
+exports.setHeaderFields = setHeaderFields;
+const ESCAPES = { n: '\n', t: '\t', r: '\r', '"': '"', '\\': '\\', a: '\x07', b: '\b', f: '\f', v: '\v' };
+function unquote(line) {
+    const m = /^"(.*)"\s*$/.exec(line.trim());
+    if (!m)
+        throw new Error(`Malformed PO string: ${line}`);
+    return m[1].replace(/\\(?:([0-7]{1,3})|x([0-9a-fA-F]{1,2})|(.))/g, (_, oct, hex, ch) => {
+        if (oct)
+            return String.fromCharCode(parseInt(oct, 8));
+        if (hex)
+            return String.fromCharCode(parseInt(hex, 16));
+        return ESCAPES[ch] ?? ch;
+    });
+}
+function entryKey(msgctxt, msgid) {
+    return `${msgctxt ?? ''}\u0004${msgid}`;
+}
+function emptyEntry() {
+    return { translatorComments: [], extractedComments: [], references: [], flags: [], previous: [], msgid: '', msgstr: [], obsolete: false, dirty: false };
+}
+function parsePo(content) {
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    const lines = content.replace(/^\uFEFF/, '').split(/\r?\n/);
+    const entries = [];
+    let cur = emptyEntry();
+    let curLines = [];
+    let hasKeyword = false;
+    /** Which field continuation strings append to. */
+    let field = null;
+    const finish = () => {
+        // Drop trailing blank lines from the raw block.
+        while (curLines.length && !curLines[curLines.length - 1].trim())
+            curLines.pop();
+        if (hasKeyword) {
+            cur.raw = curLines.join(newline);
+            entries.push(cur);
+        }
+        else if (curLines.some((l) => l.trim())) {
+            // Comments with no entry after them (end of file): keep as a raw block.
+            cur.raw = curLines.join(newline);
+            cur.obsolete = true;
+            cur.msgid = `\u0000orphan-${entries.length}`;
+            entries.push(cur);
+        }
+        cur = emptyEntry();
+        curLines = [];
+        hasKeyword = false;
+        field = null;
+    };
+    const append = (value) => {
+        if (!field)
+            return;
+        if (field.kind === 'msgctxt')
+            cur.msgctxt = (cur.msgctxt ?? '') + value;
+        else if (field.kind === 'msgid')
+            cur.msgid += value;
+        else if (field.kind === 'msgid_plural')
+            cur.msgidPlural = (cur.msgidPlural ?? '') + value;
+        else
+            cur.msgstr[field.index] = (cur.msgstr[field.index] ?? '') + value;
+    };
+    for (const rawLine of lines) {
+        let line = rawLine;
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (hasKeyword)
+                finish();
+            else if (curLines.length)
+                curLines.push(rawLine);
+            continue;
+        }
+        let obsolete = false;
+        if (trimmed.startsWith('#~')) {
+            obsolete = true;
+            line = trimmed.replace(/^#~\s?/, '');
+            if (line.startsWith('|'))
+                line = `#${line}`; // #~| previous
+        }
+        const t = line.trim();
+        const isComment = t.startsWith('#');
+        const isKeyword = /^(msgctxt|msgid|msgid_plural|msgstr(\[\d+\])?)\s/.test(t);
+        // A comment or a new msgctxt/msgid after a complete entry starts a new one.
+        if (hasKeyword && (isComment || /^(msgctxt|msgid)\s/.test(t)) && (field?.kind === 'msgstr'))
+            finish();
+        curLines.push(rawLine);
+        if (obsolete)
+            cur.obsolete = true;
+        if (isComment) {
+            if (t.startsWith('#.'))
+                cur.extractedComments.push(t.slice(2).trim());
+            else if (t.startsWith('#:'))
+                cur.references.push(...t.slice(2).trim().split(/\s+/).filter(Boolean));
+            else if (t.startsWith('#,'))
+                cur.flags.push(...t.slice(2).split(',').map((f) => f.trim()).filter(Boolean));
+            else if (t.startsWith('#|'))
+                cur.previous.push(t.slice(2).trim());
+            else
+                cur.translatorComments.push(t.replace(/^#\s?/, ''));
+            continue;
+        }
+        if (isKeyword) {
+            hasKeyword = true;
+            const m = /^(msgctxt|msgid_plural|msgid|msgstr)(?:\[(\d+)\])?\s+(.*)$/.exec(t);
+            const kind = m[1];
+            const index = m[2] !== undefined ? Number(m[2]) : 0;
+            field = { kind, index };
+            if (kind === 'msgstr' && cur.msgstr[index] === undefined)
+                cur.msgstr[index] = '';
+            if (kind === 'msgctxt')
+                cur.msgctxt = '';
+            append(unquote(m[3]));
+            continue;
+        }
+        if (t.startsWith('"')) {
+            append(unquote(t));
+            continue;
+        }
+        throw new Error(`Unrecognized PO line: ${rawLine}`);
+    }
+    finish();
+    for (const e of entries)
+        e.msgstr = Array.from({ length: e.msgstr.length }, (_, i) => e.msgstr[i] ?? '');
+    const headerIdx = entries.findIndex((e) => !e.obsolete && e.msgid === '' && e.msgctxt === undefined);
+    const header = headerIdx !== -1 ? entries.splice(headerIdx, 1)[0] : undefined;
+    return { header, entries, newline };
+}
+// ── Serialization ────────────────────────────────────────────
+function escapePo(s) {
+    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\t/g, '\\t').replace(/\r/g, '\\r').replace(/\n/g, '\\n')
+        // eslint-disable-next-line no-control-regex -- escaping control characters is the point
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, '0')}`);
+}
+/** Split escaped text into pieces of at most `width` chars, breaking after spaces. */
+function wrapEscaped(text, width) {
+    const out = [];
+    let rest = text;
+    while (rest.length > width) {
+        let cut = rest.lastIndexOf(' ', width - 1);
+        if (cut <= 0) {
+            cut = rest.indexOf(' ', width);
+            if (cut === -1)
+                break;
+        }
+        // Don't split inside an escape sequence.
+        let pieceEnd = cut + 1;
+        let backslashes = 0;
+        for (let k = pieceEnd - 1; k >= 0 && rest[k] === '\\'; k--)
+            backslashes++;
+        if (backslashes % 2 === 1)
+            pieceEnd++;
+        out.push(rest.slice(0, pieceEnd));
+        rest = rest.slice(pieceEnd);
+    }
+    if (rest || out.length === 0)
+        out.push(rest);
+    return out;
+}
+function serializeString(keyword, value, prefix = '') {
+    const pieces = value.split(/(?<=\n)/).map(escapePo);
+    const single = `${prefix}${keyword} "${pieces.join('')}"`;
+    if (pieces.length <= 1 && single.length <= 79)
+        return [single];
+    const lines = [`${prefix}${keyword} ""`];
+    for (const p of pieces)
+        for (const w of wrapEscaped(p, 77 - prefix.length))
+            lines.push(`${prefix}"${w}"`);
+    return lines;
+}
+function packed(prefix, items) {
+    const lines = [];
+    let cur = '';
+    for (const it of items) {
+        if (cur && `${prefix} ${cur} ${it}`.length > 79) {
+            lines.push(`${prefix} ${cur}`);
+            cur = it;
+        }
+        else {
+            cur = cur ? `${cur} ${it}` : it;
+        }
+    }
+    if (cur)
+        lines.push(`${prefix} ${cur}`);
+    return lines;
+}
+function serializeEntry(e) {
+    const p = e.obsolete ? '#~ ' : '';
+    const lines = [];
+    for (const c of e.translatorComments)
+        lines.push(c ? `# ${c}` : '#');
+    for (const c of e.extractedComments)
+        lines.push(`#. ${c}`);
+    if (e.references.length)
+        lines.push(...packed('#:', e.references));
+    if (e.flags.length)
+        lines.push(`#, ${e.flags.join(', ')}`);
+    for (const prev of e.previous)
+        lines.push(`#| ${prev}`);
+    if (e.msgctxt !== undefined)
+        lines.push(...serializeString('msgctxt', e.msgctxt, p));
+    lines.push(...serializeString('msgid', e.msgid, p));
+    if (e.msgidPlural !== undefined) {
+        lines.push(...serializeString('msgid_plural', e.msgidPlural, p));
+        e.msgstr.forEach((s, i) => lines.push(...serializeString(`msgstr[${i}]`, s, p)));
+    }
+    else {
+        lines.push(...serializeString('msgstr', e.msgstr[0] ?? '', p));
+    }
+    return lines;
+}
+function serializePo(file) {
+    const blocks = [];
+    const nl = file.newline;
+    const render = (e) => (!e.dirty && e.raw !== undefined ? e.raw : serializeEntry(e).join(nl));
+    if (file.header)
+        blocks.push(render(file.header));
+    for (const e of file.entries)
+        blocks.push(render(e));
+    return blocks.join(nl + nl) + nl;
+}
+// ── Header fields ────────────────────────────────────────────
+function headerFields(header) {
+    if (!header)
+        return [];
+    return (header.msgstr[0] ?? '')
+        .split('\n')
+        .filter((l) => l.includes(':'))
+        .map((l) => {
+        const i = l.indexOf(':');
+        return [l.slice(0, i).trim(), l.slice(i + 1).trim()];
+    });
+}
+function getHeaderField(header, name) {
+    return headerFields(header).find(([k]) => k.toLowerCase() === name.toLowerCase())?.[1];
+}
+/** Set header fields (in place, keeping order; new fields are appended). */
+function setHeaderFields(header, updates) {
+    const fields = headerFields(header);
+    let changed = false;
+    for (const [name, value] of updates) {
+        const existing = fields.find(([k]) => k.toLowerCase() === name.toLowerCase());
+        if (existing) {
+            if (existing[1] !== value) {
+                existing[1] = value;
+                changed = true;
+            }
+        }
+        else {
+            fields.push([name, value]);
+            changed = true;
+        }
+    }
+    if (changed) {
+        header.msgstr = [fields.map(([k, v]) => `${k}: ${v}\n`).join('')];
+        header.dirty = true;
+    }
+    return changed;
+}

package/dist/django/python-extract.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Django Python extraction.
+ *
+ * Finds two kinds of strings in a .py file:
+ *
+ *  1. Strings already marked for translation — `_()`, `gettext()`,
+ *     `gettext_lazy()`, `ngettext()`, `pgettext()`, `npgettext()` and their
+ *     lazy/legacy variants, under whatever local names the file imports them
+ *     as. These go into the catalogue as-is.
+ *
+ *  2. Hardcoded user-facing strings in places Django renders to users, which
+ *     the injector wraps with gettext / gettext_lazy:
+ *       - verbose_name, verbose_name_plural, help_text, label, empty_label,
+ *         empty_value_display keyword arguments; `description=` on
+ *         @admin.action / @admin.display; `message=` on validators;
+ *       - labels in `choices` (CHOICES lists, choices=, TextChoices members);
+ *       - error_messages dicts and widget attrs (placeholder, title, …);
+ *       - messages.info/success/… and ModelAdmin.message_user() text,
+ *         ValidationError messages — and string variables passed to them;
+ *       - text returned by template tags and filters (templatetags/*.py).
+ *
+ * Everything else (dict keys, identifiers, log lines, URLs, codes) is left
+ * alone: wrapping a string that is not shown to users changes behaviour.
+ * f-strings become `_("… %(name)s …") % {"name": expr}`; f-strings this can't
+ * rewrite safely are reported, not guessed at.
+ */
+import { type DjangoFileAnalysis } from './types';
+export interface PythonExtractOptions {
+    /** Relative path of the file (decides template-tag handling). */
+    filePath: string;
+}
+/** A string that reads as words, not an identifier, path or code. */
+export declare function looksLikeNaturalLanguage(text: string): boolean;
+export declare function extractDjangoPython(src: string, options: PythonExtractOptions): DjangoFileAnalysis;