@babelize/engine 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,65 @@
+/**
+ * A small Python tokenizer: enough structure to find string literals, the
+ * calls/brackets around them and the def/class scopes they live in, without
+ * a Python runtime. It never rewrites anything itself — the extractor and
+ * injector use token offsets to edit the original text byte-for-byte.
+ */
+export type PyTokenType = 'name' | 'number' | 'string' | 'op' | 'comment';
+export interface PyStringInfo {
+    /** Lower-cased prefix letters, e.g. '', 'r', 'f', 'rb'. */
+    prefix: string;
+    /** The quote sequence: ', ", ''' or """. */
+    quote: string;
+    raw: boolean;
+    f: boolean;
+    bytes: boolean;
+    /** Offsets of the text between the quotes. */
+    bodyStart: number;
+    bodyEnd: number;
+}
+export interface PyToken {
+    type: PyTokenType;
+    value: string;
+    start: number;
+    end: number;
+    /** 1-based line of the token start. */
+    line: number;
+    str?: PyStringInfo;
+}
+export interface PyLogicalLine {
+    /** Indentation (columns) of the first token. */
+    indent: number;
+    tokens: PyToken[];
+    /** Comments that sit on the physical lines of this logical line. */
+    comments: PyToken[];
+}
+/**
+ * End (exclusive, after the closing `}`) of an f-string replacement field
+ * whose expression starts at `i`. Nested brackets and strings (including the
+ * same quote type, legal since Python 3.12) are skipped.
+ */
+export declare function scanFieldEnd(src: string, i: number): number;
+export declare function tokenizePython(src: string): PyToken[];
+/**
+ * Group tokens into logical lines: a newline ends a statement unless it is
+ * inside brackets (or a string, or after a backslash continuation).
+ */
+export declare function logicalLines(src: string, tokens: PyToken[]): PyLogicalLine[];
+/** The runtime value of a (non-f) string literal's body. */
+export declare function decodePythonString(body: string, raw: boolean): string;
+/** A double-quoted Python string literal whose value is `value`. */
+export declare function pythonStringLiteral(value: string): string;
+export interface FStringPart {
+    kind: 'text' | 'field';
+    /** Text (already unescaped, with {{ }} collapsed) or the field's expression source. */
+    value: string;
+    conversion?: string;
+    formatSpec?: string;
+    /** `{x=}` self-documenting expression. */
+    debug?: boolean;
+}
+/**
+ * Split an f-string body into literal text and replacement fields. Returns
+ * null for fields this tool won't rewrite (nested fields in format specs).
+ */
+export declare function parseFString(body: string, raw: boolean): FStringPart[] | null;

package/dist/django/python-lexer.js

@@ -0,0 +1,398 @@
+"use strict";
+/**
+ * A small Python tokenizer: enough structure to find string literals, the
+ * calls/brackets around them and the def/class scopes they live in, without
+ * a Python runtime. It never rewrites anything itself — the extractor and
+ * injector use token offsets to edit the original text byte-for-byte.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanFieldEnd = scanFieldEnd;
+exports.tokenizePython = tokenizePython;
+exports.logicalLines = logicalLines;
+exports.decodePythonString = decodePythonString;
+exports.pythonStringLiteral = pythonStringLiteral;
+exports.parseFString = parseFString;
+const OPERATORS = [
+    '**=', '//=', '>>=', '<<=', '...', '->', ':=', '==', '!=', '<=', '>=', '**', '//', '<<', '>>',
+    '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '@=',
+];
+const STRING_PREFIX = /^(?:[rRuUbBfF]|[rR][bBfF]|[bBfF][rR])$/;
+/** Position after a string literal that starts with its quote at `q` (prefix already consumed). */
+function scanStringEnd(src, q, f) {
+    const quote = src.startsWith(src[q].repeat(3), q) ? src[q].repeat(3) : src[q];
+    let i = q + quote.length;
+    const triple = quote.length === 3;
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === '\\') {
+            i += 2;
+            continue;
+        }
+        if (!triple && ch === '\n')
+            return null; // unterminated single-line string
+        if (src.startsWith(quote, i))
+            return { end: i + quote.length, quote };
+        if (f && ch === '{') {
+            if (src[i + 1] === '{') {
+                i += 2;
+                continue;
+            }
+            const fieldEnd = scanFieldEnd(src, i + 1);
+            if (fieldEnd === -1)
+                return null;
+            i = fieldEnd;
+            continue;
+        }
+        i++;
+    }
+    return null;
+}
+/**
+ * End (exclusive, after the closing `}`) of an f-string replacement field
+ * whose expression starts at `i`. Nested brackets and strings (including the
+ * same quote type, legal since Python 3.12) are skipped.
+ */
+function scanFieldEnd(src, i) {
+    let depth = 0;
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === '\'' || ch === '"') {
+            // A nested string literal, possibly with a prefix just before it.
+            let p = i;
+            while (p > 0 && /[rRbBfFuU]/.test(src[p - 1]))
+                p--;
+            const nestedF = /[fF]/.test(src.slice(p, i));
+            const r = scanStringEnd(src, i, nestedF);
+            if (!r)
+                return -1;
+            i = r.end;
+            continue;
+        }
+        if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        else if (ch === ')' || ch === ']')
+            depth--;
+        else if (ch === '}') {
+            if (depth === 0)
+                return i + 1;
+            depth--;
+        }
+        i++;
+    }
+    return -1;
+}
+function tokenizePython(src) {
+    const tokens = [];
+    let i = 0;
+    let line = 1;
+    const len = src.length;
+    const push = (type, start, end, str) => {
+        tokens.push({ type, value: src.slice(start, end), start, end, line, str });
+        for (let k = start; k < end; k++)
+            if (src.charCodeAt(k) === 10)
+                line++;
+    };
+    while (i < len) {
+        const ch = src[i];
+        if (ch === '\n') {
+            line++;
+            i++;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '\f') {
+            i++;
+            continue;
+        }
+        if (ch === '\\' && (src[i + 1] === '\n' || (src[i + 1] === '\r' && src[i + 2] === '\n'))) {
+            i += src[i + 1] === '\r' ? 3 : 2;
+            line++;
+            continue;
+        }
+        if (ch === '#') {
+            let end = src.indexOf('\n', i);
+            if (end === -1)
+                end = len;
+            push('comment', i, end);
+            i = end;
+            continue;
+        }
+        if (/[A-Za-z_\u0080-￿]/.test(ch)) {
+            let j = i + 1;
+            while (j < len && /[\w\u0080-￿]/.test(src[j]))
+                j++;
+            const word = src.slice(i, j);
+            if ((src[j] === '"' || src[j] === "'") && STRING_PREFIX.test(word)) {
+                const prefix = word.toLowerCase();
+                const f = prefix.includes('f');
+                const r = scanStringEnd(src, j, f);
+                if (r) {
+                    push('string', i, r.end, {
+                        prefix,
+                        quote: r.quote,
+                        raw: prefix.includes('r'),
+                        f,
+                        bytes: prefix.includes('b'),
+                        bodyStart: j + r.quote.length,
+                        bodyEnd: r.end - r.quote.length,
+                    });
+                    i = r.end;
+                    continue;
+                }
+            }
+            push('name', i, j);
+            i = j;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            const r = scanStringEnd(src, i, false);
+            if (r) {
+                push('string', i, r.end, {
+                    prefix: '', quote: r.quote, raw: false, f: false, bytes: false,
+                    bodyStart: i + r.quote.length, bodyEnd: r.end - r.quote.length,
+                });
+                i = r.end;
+                continue;
+            }
+            // Unterminated: treat the quote as an operator so scanning continues.
+            push('op', i, i + 1);
+            i++;
+            continue;
+        }
+        if (/[0-9]/.test(ch) || (ch === '.' && /[0-9]/.test(src[i + 1] ?? ''))) {
+            const m = /^(?:0[xX][0-9a-fA-F_]+|0[oO][0-7_]+|0[bB][01_]+|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d+)?[jJ]?)/.exec(src.slice(i, i + 64));
+            const end = i + (m ? m[0].length : 1);
+            push('number', i, end);
+            i = end;
+            continue;
+        }
+        const op = OPERATORS.find((o) => src.startsWith(o, i));
+        const end = i + (op ? op.length : 1);
+        push('op', i, end);
+        i = end;
+    }
+    return tokens;
+}
+/** Column of `offset` within its physical line (tabs count as 8, like Python). */
+function columnOf(src, offset) {
+    let col = 0;
+    for (let k = src.lastIndexOf('\n', offset - 1) + 1; k < offset; k++) {
+        col = src[k] === '\t' ? col + 8 - (col % 8) : col + 1;
+    }
+    return col;
+}
+function lastTokenLine(line) {
+    const t = line.tokens[line.tokens.length - 1];
+    return t.line + (t.value.match(/\n/g)?.length ?? 0);
+}
+/**
+ * Group tokens into logical lines: a newline ends a statement unless it is
+ * inside brackets (or a string, or after a backslash continuation).
+ */
+function logicalLines(src, tokens) {
+    const lines = [];
+    let current = null;
+    let depth = 0;
+    let pendingComments = [];
+    for (const tok of tokens) {
+        if (tok.type === 'comment') {
+            if (current && depth > 0)
+                current.comments.push(tok);
+            else if (current && current.tokens.length && tok.line === lastTokenLine(current))
+                current.comments.push(tok);
+            else
+                pendingComments.push(tok);
+            continue;
+        }
+        // A token on a new physical line, outside brackets, starts a new statement —
+        // unless the previous token ended with a backslash continuation (no newline
+        // between them in tokens terms, detected by the source between them).
+        const prev = current?.tokens[current.tokens.length - 1];
+        const between = prev ? src.slice(prev.end, tok.start) : '';
+        const continued = /\\\r?\n/.test(between);
+        if (!current || (prev && depth === 0 && !continued && /\n/.test(between))) {
+            current = { indent: columnOf(src, tok.start), tokens: [], comments: pendingComments };
+            pendingComments = [];
+            lines.push(current);
+        }
+        if (tok.type === 'op') {
+            if (tok.value === '(' || tok.value === '[' || tok.value === '{')
+                depth++;
+            else if ((tok.value === ')' || tok.value === ']' || tok.value === '}') && depth > 0)
+                depth--;
+        }
+        if (depth === 0 && tok.type === 'op' && tok.value === ';') {
+            // `a = 1; b = 2` — split into separate statements at the same indent.
+            const indent = current.indent;
+            current = { indent, tokens: [], comments: [] };
+            lines.push(current);
+            continue;
+        }
+        current.tokens.push(tok);
+    }
+    return lines.filter((l) => l.tokens.length > 0);
+}
+// ── String literal values ─────────────────────────────────────
+const SIMPLE_ESCAPES = {
+    '\\': '\\', "'": "'", '"': '"', a: '\x07', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v',
+};
+/** The runtime value of a (non-f) string literal's body. */
+function decodePythonString(body, raw) {
+    if (raw)
+        return body.replace(/\r\n/g, '\n');
+    let out = '';
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch === '\r' && body[i + 1] === '\n')
+            continue;
+        if (ch !== '\\') {
+            out += ch;
+            continue;
+        }
+        const next = body[i + 1];
+        if (next === undefined) {
+            out += '\\';
+            break;
+        }
+        if (next === '\n') {
+            i++;
+            continue;
+        }
+        if (next === '\r' && body[i + 2] === '\n') {
+            i += 2;
+            continue;
+        }
+        if (next in SIMPLE_ESCAPES) {
+            out += SIMPLE_ESCAPES[next];
+            i++;
+            continue;
+        }
+        if (/[0-7]/.test(next)) {
+            const m = /^[0-7]{1,3}/.exec(body.slice(i + 1))[0];
+            out += String.fromCharCode(parseInt(m, 8));
+            i += m.length;
+            continue;
+        }
+        const hex = next === 'x' ? 2 : next === 'u' ? 4 : next === 'U' ? 8 : 0;
+        if (hex) {
+            const digits = body.slice(i + 2, i + 2 + hex);
+            if (digits.length === hex && /^[0-9a-fA-F]+$/.test(digits)) {
+                out += String.fromCodePoint(parseInt(digits, 16));
+                i += 1 + hex;
+                continue;
+            }
+        }
+        // Unknown escape (or \N{NAME}): Python keeps it as written.
+        out += ch;
+    }
+    return out;
+}
+/** A double-quoted Python string literal whose value is `value`. */
+function pythonStringLiteral(value) {
+    let out = '"';
+    for (const ch of value) {
+        const code = ch.codePointAt(0);
+        if (ch === '\\')
+            out += '\\\\';
+        else if (ch === '"')
+            out += '\\"';
+        else if (ch === '\n')
+            out += '\\n';
+        else if (ch === '\t')
+            out += '\\t';
+        else if (ch === '\r')
+            out += '\\r';
+        else if (code < 0x20 || code === 0x7f)
+            out += `\\x${code.toString(16).padStart(2, '0')}`;
+        else
+            out += ch;
+    }
+    return out + '"';
+}
+/**
+ * Split an f-string body into literal text and replacement fields. Returns
+ * null for fields this tool won't rewrite (nested fields in format specs).
+ */
+function parseFString(body, raw) {
+    const parts = [];
+    let text = '';
+    let i = 0;
+    const flush = () => {
+        if (text)
+            parts.push({ kind: 'text', value: decodePythonString(text, raw) });
+        text = '';
+    };
+    while (i < body.length) {
+        const ch = body[i];
+        if (ch === '\\' && !raw) {
+            text += body.slice(i, i + 2);
+            i += 2;
+            continue;
+        }
+        if (ch === '{' && body[i + 1] === '{') {
+            text += '{';
+            i += 2;
+            continue;
+        }
+        if (ch === '}' && body[i + 1] === '}') {
+            text += '}';
+            i += 2;
+            continue;
+        }
+        if (ch === '{') {
+            flush();
+            const end = scanFieldEnd(body, i + 1);
+            if (end === -1)
+                return null;
+            const inner = body.slice(i + 1, end - 1);
+            // Split off !conversion and :format_spec at depth 0, outside strings.
+            let exprEnd = inner.length;
+            let conversion;
+            let formatSpec;
+            let depth = 0;
+            for (let k = 0; k < inner.length; k++) {
+                const c = inner[k];
+                if (c === '\'' || c === '"') {
+                    const q = inner.startsWith(c.repeat(3), k) ? c.repeat(3) : c;
+                    const close = inner.indexOf(q, k + q.length);
+                    if (close === -1)
+                        return null;
+                    k = close + q.length - 1;
+                    continue;
+                }
+                if (c === '(' || c === '[' || c === '{')
+                    depth++;
+                else if (c === ')' || c === ']' || c === '}')
+                    depth--;
+                else if (depth === 0 && c === '!' && inner[k + 1] !== '=') {
+                    exprEnd = k;
+                    const rest = inner.slice(k + 1);
+                    const colon = rest.indexOf(':');
+                    conversion = colon === -1 ? rest : rest.slice(0, colon);
+                    if (colon !== -1)
+                        formatSpec = rest.slice(colon + 1);
+                    break;
+                }
+                else if (depth === 0 && c === ':') {
+                    exprEnd = k;
+                    formatSpec = inner.slice(k + 1);
+                    break;
+                }
+            }
+            let expr = inner.slice(0, exprEnd);
+            let debug = false;
+            if (/=\s*$/.test(expr) && !/[=!<>]=\s*$/.test(expr)) {
+                debug = true;
+                expr = expr.replace(/=\s*$/, '');
+            }
+            if (formatSpec !== undefined && formatSpec.includes('{'))
+                return null;
+            parts.push({ kind: 'field', value: expr.trim(), conversion, formatSpec, debug });
+            i = end;
+            continue;
+        }
+        text += ch;
+        i++;
+    }
+    flush();
+    return parts;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Django Template Language extraction.
+ *
+ * Finds strings already marked in templates — `{% translate %}` / `{% trans %}`,
+ * `{% blocktranslate %}` / `{% blocktrans %}` (with count/plural, context,
+ * with/trimmed/asvar) and `_("…")` in filter and tag arguments — and
+ * hardcoded user-facing text the injector can mark:
+ *
+ *   - text in the page, as `{% translate "…" %}`, or as one
+ *     `{% blocktranslate %}` when the sentence carries `{{ variables }}` or
+ *     inline markup (`<a>`, `<strong>`, …). Variables with lookups or
+ *     filters are bound with `with name=expr` because blocktranslate only
+ *     accepts plain names;
+ *   - title / alt / placeholder / aria-label attributes and button values;
+ *   - string arguments of the `default` / `default_if_none` filters.
+ *
+ * Every edit is an exact replacement of the original span, so nothing else
+ * in the template (whitespace, attribute order, other tags) changes.
+ * Text inside <script>, <style>, <pre>, <code>, <textarea>, <svg>,
+ * {% comment %} and {% verbatim %} is never touched.
+ */
+import { type DjangoFileAnalysis, type TemplateEdit } from './types';
+/** Split DTL tag contents into bits, keeping quoted strings (and _("…")) whole. */
+export declare function smartSplit(text: string): string[];
+/** Django's trim_whitespace() for {% blocktranslate trimmed %}. */
+export declare function trimWhitespace(s: string): string;
+export interface TemplateExtractOptions {
+    filePath: string;
+}
+export declare function extractDjangoTemplate(src: string, _options: TemplateExtractOptions): DjangoFileAnalysis & {
+    extraEdits: TemplateEdit[];
+};