@babelize/engine 0.0.0-stage → 0.1.2

package/dist/django/template-extract.js

@@ -0,0 +1,680 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartSplit = smartSplit;
+exports.trimWhitespace = trimWhitespace;
+exports.extractDjangoTemplate = extractDjangoTemplate;
+const types_1 = require("./types");
+/** Inline elements that may sit inside a translated sentence. */
+const INLINE = new Set([
+    'a', 'abbr', 'b', 'bdi', 'bdo', 'cite', 'data', 'dfn', 'em', 'i', 'kbd', 'mark', 'q', 's', 'samp',
+    'small', 'span', 'strong', 'sub', 'sup', 'time', 'u', 'var',
+]);
+/** Elements whose content is never treated as page text. */
+const SKIP_CONTENT = new Set(['script', 'style', 'pre', 'code', 'textarea', 'svg', 'math', 'template']);
+const RAW_TEXT = new Set(['script', 'style']);
+const TEXT_ATTRS = new Set(['title', 'alt', 'placeholder', 'aria-label', 'aria-description']);
+const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const ENTITY = /&(?:[a-zA-Z][a-zA-Z0-9]{1,31}|#\d{1,7}|#x[0-9a-fA-F]{1,6});/g;
+const SEPARATOR = String.raw `(?:&(?:mdash|ndash|middot|bull|raquo|laquo|nbsp|#8212|#8211|#183);|[—–·•|»«])`;
+const SEPARATOR_LEAD = new RegExp(`^(?:${SEPARATOR}\\s*)+`);
+const SEPARATOR_TRAIL = new RegExp(`(?:\\s*${SEPARATOR})+$`);
+/** Split DTL tag contents into bits, keeping quoted strings (and _("…")) whole. */
+function smartSplit(text) {
+    const bits = [];
+    const re = /(?:[^\s'"]*(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')[^\s'"]*)+|\S+/g;
+    for (const m of text.matchAll(re))
+        bits.push(m[0]);
+    return bits;
+}
+/** Value of a DTL string literal ("…" or '…'), or null if `bit` isn't one. */
+function literalValue(bit) {
+    const m = /^_\((.*)\)$/s.exec(bit);
+    const b = m ? m[1] : bit;
+    if (b.length < 2 || !((b[0] === '"' || b[0] === "'") && b[b.length - 1] === b[0]))
+        return null;
+    const q = b[0];
+    return b.slice(1, -1).replace(new RegExp(`\\\\${q}`, 'g'), q).replace(/\\\\/g, '\\');
+}
+/** Django's trim_whitespace() for {% blocktranslate trimmed %}. */
+function trimWhitespace(s) {
+    return s.trim().replace(/\s*\n\s*/g, ' ');
+}
+function lineAt(src, offset) {
+    let n = 1;
+    for (let i = 0; i < offset && i < src.length; i++)
+        if (src.charCodeAt(i) === 10)
+            n++;
+    return n;
+}
+function hasLetters(text) {
+    return /\p{L}/u.test(text.replace(ENTITY, ' '));
+}
+/** End of a DTL token starting at `i` (`{%`, `{{`, `{#`), or -1. DTL tokens never span lines. */
+function dtlEnd(src, i) {
+    const close = src[i + 1] === '%' ? '%}' : src[i + 1] === '{' ? '}}' : '#}';
+    const nl = src.indexOf('\n', i);
+    const end = src.indexOf(close, i + 2);
+    if (end === -1 || (nl !== -1 && nl < end))
+        return -1;
+    return end + 2;
+}
+/** End (after `>`) of an HTML tag starting at `i`, skipping quoted values and DTL tokens. */
+function htmlTagEnd(src, i) {
+    let k = i + 1;
+    let quote = '';
+    while (k < src.length) {
+        const ch = src[k];
+        if (!quote && ch === '{' && (src[k + 1] === '%' || src[k + 1] === '{' || src[k + 1] === '#')) {
+            const e = dtlEnd(src, k);
+            if (e !== -1) {
+                k = e;
+                continue;
+            }
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = '';
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (ch === '>') {
+            return k + 1;
+        }
+        else if (ch === '<') {
+            return -1;
+        }
+        k++;
+    }
+    return -1;
+}
+function parseAttrs(src, start, end) {
+    const attrs = [];
+    const text = src.slice(start, end);
+    const re = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    // Mask DTL tokens so `{% if x %}` inside a tag isn't read as attributes.
+    const masked = text.replace(/\{%.*?%\}|\{\{.*?\}\}|\{#.*?#\}/g, (m) => '\u0000'.repeat(m.length));
+    for (const m of masked.matchAll(re)) {
+        const name = m[1].toLowerCase();
+        if (name.includes('\u0000'))
+            continue;
+        if (m[2] === undefined && m[3] === undefined && m[4] === undefined)
+            continue;
+        const quote = m[2] !== undefined ? '"' : m[3] !== undefined ? "'" : '';
+        const rawVal = m[2] ?? m[3] ?? m[4] ?? '';
+        const valueOffsetInMatch = m[0].lastIndexOf(rawVal + quote) - (quote ? 0 : 0);
+        const valueStart = start + m.index + valueOffsetInMatch;
+        const valueEnd = valueStart + rawVal.length;
+        attrs.push({ name, value: src.slice(valueStart, valueEnd), valueStart, valueEnd, quote });
+    }
+    return attrs;
+}
+/** `{% translate "…" %}` for `text`, or null when it can't be quoted safely. */
+function translateTag(text, preferQuote = '"', onlyPreferred = false) {
+    if (text.includes('\\'))
+        return null;
+    const other = preferQuote === '"' ? "'" : '"';
+    if (!text.includes(preferQuote))
+        return `{% translate ${preferQuote}${text}${preferQuote} %}`;
+    if (!onlyPreferred && !text.includes(other))
+        return `{% translate ${other}${text}${other} %}`;
+    return null;
+}
+/** Variable name for a `{{ expr }}` inside blocktranslate. */
+function bindingName(expr) {
+    const base = expr.split('|')[0].trim();
+    const parts = base.split('.').filter((p) => /^[A-Za-z_]\w*$/.test(p));
+    const last = parts[parts.length - 1] ?? 'value';
+    return last === 'super' && parts.length > 1 ? 'block_super' : last;
+}
+function extractDjangoTemplate(src, _options) {
+    const findings = [];
+    const unwired = [];
+    const extraEdits = [];
+    let run = [];
+    /** Open SKIP_CONTENT elements (by name) we are currently inside. */
+    const skipStack = [];
+    /** Translator comment from the closest preceding {# Translators: … #}. */
+    let pendingComment = null;
+    const comment = (at) => {
+        if (!pendingComment)
+            return [];
+        const between = src.slice(pendingComment.end, at);
+        return /^\s*$/.test(between) && (between.match(/\n/g)?.length ?? 0) <= 1 ? [pendingComment.text] : [];
+    };
+    const addWrapped = (msgid, line, extra = {}) => {
+        if (!msgid)
+            return;
+        findings.push({
+            message: {
+                msgid,
+                msgidPlural: extra.plural,
+                msgctxt: extra.ctx,
+                flags: (0, types_1.formatFlags)(msgid, extra.plural).filter((f) => f === 'python-format'),
+                comments: extra.comments ?? [],
+            },
+            line,
+            wrapped: true,
+        });
+    };
+    const addHardcoded = (msgid, start, end, replacement, line) => {
+        findings.push({
+            message: { msgid, flags: (0, types_1.formatFlags)(msgid).filter((f) => f === 'python-format'), comments: comment(start) },
+            line,
+            wrapped: false,
+            edit: { kind: 'template', start, end, replacement },
+        });
+    };
+    /** `_("…")` inside a DTL var or tag: already marked. */
+    const scanUnderscore = (token, offset) => {
+        for (const m of token.matchAll(/_\(\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*\)/g)) {
+            const v = literalValue(m[1]);
+            if (v)
+                addWrapped(v.replace(/%/g, '%%'), lineAt(src, offset + m.index));
+        }
+    };
+    /** `{{ x|default:"Text" }}` → `{{ x|default:_("Text") }}` */
+    const scanFilterDefaults = (token, offset) => {
+        if (skipStack.length)
+            return;
+        for (const m of token.matchAll(/\|\s*(default|default_if_none)\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g)) {
+            const lit = m[2];
+            const v = literalValue(lit);
+            if (!v || !hasLetters(v) || v.includes('\\'))
+                continue;
+            const litStart = offset + m.index + m[0].length - lit.length;
+            addHardcoded(v.replace(/%/g, '%%'), litStart, litStart + lit.length, `_(${lit})`, lineAt(src, litStart));
+        }
+    };
+    // ── Hardcoded text runs ─────────────────────────────────────
+    const flush = () => {
+        const items = run;
+        run = [];
+        emitRun(items);
+    };
+    const emitRun = (input) => {
+        let items = [...input];
+        // Trim whitespace-only text at the edges.
+        const isBlank = (it) => it.type === 'text' && !src.slice(it.start, it.end).trim();
+        while (items.length && isBlank(items[0]))
+            items.shift();
+        while (items.length && isBlank(items[items.length - 1]))
+            items.pop();
+        if (!items.length)
+            return;
+        // Peel an element that wraps the whole run: translate its content instead.
+        for (;;) {
+            const first = items[0];
+            const last = items[items.length - 1];
+            if (first.type === 'open' && last.type === 'close' && matchingClose(items, 0) === items.length - 1) {
+                items = items.slice(1, -1);
+                while (items.length && isBlank(items[0]))
+                    items.shift();
+                while (items.length && isBlank(items[items.length - 1]))
+                    items.pop();
+                if (!items.length)
+                    return;
+                continue;
+            }
+            break;
+        }
+        const balanced = isBalanced(items);
+        const topLevelText = items.some((it, idx) => it.type === 'text' && hasLetters(src.slice(it.start, it.end)) && depthAt(items, idx) === 0) ||
+            items.some((it, idx) => it.type === 'var' && depthAt(items, idx) === 0);
+        const hasTags = items.some((it) => it.type === 'open' || it.type === 'close');
+        if (hasTags && (!balanced || !topLevelText)) {
+            // Split at the tags and handle each piece on its own.
+            let piece = [];
+            for (const it of items) {
+                if (it.type === 'open' || it.type === 'close') {
+                    emitRun(piece);
+                    piece = [];
+                }
+                else {
+                    piece.push(it);
+                }
+            }
+            emitRun(piece);
+            return;
+        }
+        const textItems = items.filter((it) => it.type === 'text');
+        if (!textItems.some((it) => hasLetters(src.slice(it.start, it.end))))
+            return;
+        // Core span: from the first non-space char to the last.
+        const first = items[0];
+        const last = items[items.length - 1];
+        let start = first.start;
+        let end = last.end;
+        if (first.type === 'text')
+            start += src.slice(first.start, first.end).length - src.slice(first.start, first.end).trimStart().length;
+        if (last.type === 'text')
+            end -= src.slice(last.start, last.end).length - src.slice(last.start, last.end).trimEnd().length;
+        // Layout separators at the edges ("&mdash; City Library", "Home |") aren't part of the text.
+        if (first.type === 'text') {
+            const lead = SEPARATOR_LEAD.exec(src.slice(start, first.end));
+            if (lead && lead[0].length < first.end - start)
+                start += lead[0].length;
+        }
+        if (last.type === 'text') {
+            const trail = SEPARATOR_TRAIL.exec(src.slice(Math.max(last.start, start), end));
+            if (trail && end - trail[0].length > start)
+                end -= trail[0].length;
+        }
+        const core = src.slice(start, end);
+        const line = lineAt(src, textItems.find((it) => hasLetters(src.slice(it.start, it.end))).start + (src.slice(textItems[0].start, textItems[0].end).length - src.slice(textItems[0].start, textItems[0].end).trimStart().length));
+        const vars = items.filter((it) => it.type === 'var');
+        const multiline = core.includes('\n');
+        if (!vars.length && !hasTags && !multiline) {
+            const tag = translateTag(core);
+            if (tag) {
+                addHardcoded(core.replace(/%/g, '%%'), start, end, tag, line);
+                return;
+            }
+        }
+        // blocktranslate: bind every non-trivial variable to a plain name.
+        const bindings = [];
+        const nameFor = new Map();
+        const allExprs = [
+            ...vars.map((v) => v.expr),
+            ...items.filter((it) => it.type === 'open').flatMap((it) => [...src.slice(it.start, it.end).matchAll(/\{\{(.*?)\}\}/g)].map((m) => m[1].trim())),
+        ];
+        for (const expr of allExprs) {
+            if (nameFor.has(expr))
+                continue;
+            if (/^[A-Za-z_]\w*$/.test(expr)) {
+                nameFor.set(expr, expr);
+                continue;
+            }
+            const base = bindingName(expr);
+            let name = base;
+            for (let n = 2; [...nameFor.values()].includes(name) || bindings.some((b) => b.name === name); n++)
+                name = `${base}${n}`;
+            nameFor.set(expr, name);
+            bindings.push({ name, expr });
+        }
+        if (allExprs.some((e) => /_\(/.test(e))) {
+            unwired.push({ line, text: core, reason: 'not wrapped: a variable inside the sentence uses _() — wrap it yourself' });
+            return;
+        }
+        // Content with variables replaced by their bound names; msgid with %(name)s.
+        let content = '';
+        let msgidRaw = '';
+        let cursor = start;
+        const pieces = items.flatMap((it) => {
+            if (it.type !== 'open')
+                return [it];
+            // Variables inside an inline tag's attributes.
+            const tagText = src.slice(it.start, it.end);
+            const sub = [];
+            let at = it.start;
+            for (const m of tagText.matchAll(/\{\{(.*?)\}\}/g)) {
+                const s = it.start + m.index;
+                if (s > at)
+                    sub.push({ type: 'text', start: at, end: s });
+                sub.push({ type: 'var', start: s, end: s + m[0].length, expr: m[1].trim() });
+                at = s + m[0].length;
+            }
+            if (at < it.end)
+                sub.push({ type: 'text', start: at, end: it.end });
+            return sub;
+        });
+        for (const it of pieces) {
+            const s = Math.max(it.start, cursor);
+            const e = Math.min(it.end, end);
+            if (e <= s)
+                continue;
+            if (it.type === 'var') {
+                const name = nameFor.get(it.expr);
+                content += `{{ ${name} }}`;
+                msgidRaw += `%(${name})s`;
+            }
+            else {
+                const t = src.slice(s, e);
+                content += t;
+                msgidRaw += t.replace(/%/g, '%%');
+            }
+            cursor = e;
+        }
+        const msgid = multiline ? trimWhitespace(msgidRaw) : msgidRaw;
+        const withPart = bindings.length ? ` with ${bindings.map((b) => `${b.name}=${b.expr}`).join(' ')}` : '';
+        const replacement = `{% blocktranslate${withPart}${multiline ? ' trimmed' : ''} %}${content}{% endblocktranslate %}`;
+        addHardcoded(msgid, start, end, replacement, line);
+    };
+    // ── Main scan ───────────────────────────────────────────────
+    let i = 0;
+    let textStart = 0;
+    const pushText = (s, e) => {
+        if (e > s && !skipStack.length)
+            run.push({ type: 'text', start: s, end: e });
+    };
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === '{' && (src[i + 1] === '%' || src[i + 1] === '{' || src[i + 1] === '#')) {
+            const end = dtlEnd(src, i);
+            if (end === -1) {
+                i++;
+                continue;
+            }
+            pushText(textStart, i);
+            const token = src.slice(i, end);
+            const inner = token.slice(2, -2).trim();
+            if (src[i + 1] === '#') {
+                const c = inner;
+                if (/^translators\b/i.test(c))
+                    pendingComment = { text: c, end };
+                flush();
+                i = textStart = end;
+                continue;
+            }
+            if (src[i + 1] === '{') {
+                scanUnderscore(token, i);
+                scanFilterDefaults(token, i);
+                if (!skipStack.length) {
+                    if (/_\(/.test(inner))
+                        flush();
+                    else
+                        run.push({ type: 'var', start: i, end, expr: inner });
+                }
+                i = textStart = end;
+                continue;
+            }
+            // {% … %}
+            flush();
+            const bits = smartSplit(inner);
+            const tagName = bits[0] ?? '';
+            if (tagName === 'comment') {
+                const close = src.slice(end).search(/\{%\s*endcomment\s*%\}/);
+                i = textStart = close === -1 ? src.length : end + close + src.slice(end + close).indexOf('%}') + 2;
+                continue;
+            }
+            if (tagName === 'verbatim') {
+                const close = src.slice(end).search(/\{%\s*endverbatim\b[^%]*%\}/);
+                i = textStart = close === -1 ? src.length : end + close + src.slice(end + close).indexOf('%}') + 2;
+                continue;
+            }
+            if (tagName === 'trans' || tagName === 'translate') {
+                const v = bits[1] ? literalValue(bits[1]) : null;
+                if (v !== null) {
+                    const ctxIdx = bits.indexOf('context');
+                    const ctx = ctxIdx !== -1 && bits[ctxIdx + 1] ? literalValue(bits[ctxIdx + 1]) ?? undefined : undefined;
+                    addWrapped(v.replace(/%/g, '%%'), lineAt(src, i), { ctx, comments: comment(i) });
+                }
+                i = textStart = end;
+                continue;
+            }
+            if (tagName === 'blocktrans' || tagName === 'blocktranslate') {
+                const r = parseBlockTranslate(src, i, end, bits);
+                if (r.msgid)
+                    addWrapped(r.msgid, lineAt(src, i), { plural: r.plural, ctx: r.ctx, comments: comment(i) });
+                i = textStart = r.end;
+                continue;
+            }
+            scanUnderscore(token, i);
+            i = textStart = end;
+            continue;
+        }
+        if (ch === '<') {
+            if (src.startsWith('<!--', i)) {
+                pushText(textStart, i);
+                flush();
+                const close = src.indexOf('-->', i + 4);
+                i = textStart = close === -1 ? src.length : close + 3;
+                continue;
+            }
+            const m = /^<\/?([A-Za-z][\w:-]*)/.exec(src.slice(i, i + 64));
+            if (!m && src[i + 1] !== '!') {
+                i++;
+                continue;
+            }
+            const end = htmlTagEnd(src, i);
+            if (end === -1) {
+                i++;
+                continue;
+            }
+            pushText(textStart, i);
+            const tagText = src.slice(i, end);
+            if (!m) {
+                // <!DOCTYPE …>
+                flush();
+                i = textStart = end;
+                continue;
+            }
+            const name = m[1].toLowerCase();
+            const closing = tagText[1] === '/';
+            if (closing) {
+                if (skipStack.length && skipStack[skipStack.length - 1] === name) {
+                    skipStack.pop();
+                    i = textStart = end;
+                    continue;
+                }
+                if (!skipStack.length && INLINE.has(name))
+                    run.push({ type: 'close', start: i, end, name });
+                else
+                    flush();
+                i = textStart = end;
+                continue;
+            }
+            const attrsStart = i + m[0].length;
+            const attrs = parseAttrs(src, attrsStart, end - 1);
+            const selfClosing = /\/\s*>$/.test(tagText) || VOID.has(name);
+            let hasTextAttr = false;
+            if (!skipStack.length) {
+                for (const a of attrs) {
+                    const isText = TEXT_ATTRS.has(a.name) ||
+                        (a.name === 'label' && ['option', 'optgroup', 'track'].includes(name)) ||
+                        (a.name === 'value' && name === 'input' && attrs.some((x) => x.name === 'type' && /^(?:submit|button|reset)$/i.test(x.value)));
+                    if (!isText || !hasLetters(a.value))
+                        continue;
+                    hasTextAttr = true;
+                    const line = lineAt(src, a.valueStart);
+                    if (/\{%|\{\{/.test(a.value)) {
+                        if (!/\{%\s*(?:trans|translate|blocktrans|blocktranslate)\b/.test(a.value)) {
+                            unwired.push({ line, text: a.value, reason: `not wrapped: ${a.name} attribute mixes text and template tags` });
+                        }
+                        continue;
+                    }
+                    const prefer = a.quote === '"' ? "'" : '"';
+                    // Inside a quoted attribute, the tag can't reuse the attribute's own quote.
+                    const tag = translateTag(a.value, prefer, !!a.quote);
+                    if (!tag) {
+                        unwired.push({ line, text: a.value, reason: `not wrapped: ${a.name} attribute contains both quote characters or a backslash` });
+                        continue;
+                    }
+                    const replacement = a.quote ? tag : `"${tag}"`;
+                    addHardcoded(a.value.replace(/%/g, '%%'), a.valueStart, a.valueEnd, replacement, line);
+                }
+                // <html lang="en"> → follow the active language (and its direction).
+                if (name === 'html') {
+                    const lang = attrs.find((a) => a.name === 'lang');
+                    const dir = attrs.find((a) => a.name === 'dir');
+                    if (lang && /^[A-Za-z]{2,3}(?:[-_][A-Za-z0-9]+)*$/.test(lang.value) && lang.quote) {
+                        extraEdits.push({
+                            kind: 'template', start: i, end: i,
+                            replacement: '{% get_current_language as LANGUAGE_CODE %}{% get_current_language_bidi as LANGUAGE_BIDI %}',
+                        });
+                        extraEdits.push({ kind: 'template', start: lang.valueStart, end: lang.valueEnd, replacement: '{{ LANGUAGE_CODE }}' });
+                        if (!dir) {
+                            const q = lang.quote;
+                            extraEdits.push({
+                                kind: 'template', start: lang.valueEnd + 1, end: lang.valueEnd + 1,
+                                replacement: ` dir=${q}{% if LANGUAGE_BIDI %}rtl{% else %}ltr{% endif %}${q}`,
+                            });
+                        }
+                    }
+                }
+            }
+            if (skipStack.length) {
+                if (!selfClosing && SKIP_CONTENT.has(name))
+                    skipStack.push(name);
+                i = textStart = end;
+                continue;
+            }
+            if (RAW_TEXT.has(name) && !selfClosing) {
+                flush();
+                // Raw text: only DTL tokens inside count (for already-marked strings).
+                const closeRe = new RegExp(`</${name}\\s*>`, 'i');
+                const rel = src.slice(end).search(closeRe);
+                const contentEnd = rel === -1 ? src.length : end + rel;
+                const body = src.slice(end, contentEnd);
+                for (const t of body.matchAll(/\{%.*?%\}|\{\{.*?\}\}/g)) {
+                    const off = end + t.index;
+                    const bits = smartSplit(t[0].slice(2, -2).trim());
+                    if (t[0].startsWith('{%') && (bits[0] === 'trans' || bits[0] === 'translate')) {
+                        const v = bits[1] ? literalValue(bits[1]) : null;
+                        if (v !== null)
+                            addWrapped(v.replace(/%/g, '%%'), lineAt(src, off));
+                    }
+                    else {
+                        scanUnderscore(t[0], off);
+                    }
+                }
+                i = textStart = contentEnd;
+                continue;
+            }
+            if (SKIP_CONTENT.has(name) && !selfClosing) {
+                flush();
+                skipStack.push(name);
+                i = textStart = end;
+                continue;
+            }
+            if (INLINE.has(name) && !hasTextAttr && !/\{%/.test(tagText)) {
+                run.push({ type: 'open', start: i, end, name, attrsHaveVars: /\{\{/.test(tagText) });
+                if (selfClosing)
+                    run.push({ type: 'close', start: end, end, name });
+            }
+            else {
+                flush();
+            }
+            i = textStart = end;
+            continue;
+        }
+        i++;
+    }
+    pushText(textStart, src.length);
+    flush();
+    findings.sort((a, b) => a.line - b.line);
+    return { findings, unwired, extraEdits };
+}
+function matchingClose(items, openIdx) {
+    let depth = 0;
+    for (let k = openIdx; k < items.length; k++) {
+        const it = items[k];
+        if (it.type === 'open')
+            depth++;
+        else if (it.type === 'close') {
+            depth--;
+            if (depth === 0)
+                return k;
+        }
+    }
+    return -1;
+}
+function isBalanced(items) {
+    const stack = [];
+    for (const it of items) {
+        if (it.type === 'open')
+            stack.push(it.name);
+        else if (it.type === 'close') {
+            if (stack.pop() !== it.name)
+                return false;
+        }
+    }
+    return stack.length === 0;
+}
+function depthAt(items, idx) {
+    let depth = 0;
+    for (let k = 0; k < idx; k++) {
+        if (items[k].type === 'open')
+            depth++;
+        else if (items[k].type === 'close')
+            depth--;
+    }
+    return depth;
+}
+/**
+ * Parse `{% blocktranslate … %}…{% plural %}…{% endblocktranslate %}` into
+ * the msgid Django looks up: text with `%` doubled and `{{ name }}` as
+ * `%(name)s`, trimmed when the tag says so.
+ */
+function parseBlockTranslate(src, tagStart, tagEnd, bits) {
+    const trimmed = bits.includes('trimmed');
+    const ctxIdx = bits.indexOf('context');
+    const ctx = ctxIdx !== -1 && bits[ctxIdx + 1] ? literalValue(bits[ctxIdx + 1]) ?? undefined : undefined;
+    const isCount = bits.includes('count');
+    let singular = '';
+    let plural = '';
+    let inPlural = false;
+    let k = tagEnd;
+    let valid = true;
+    while (k < src.length) {
+        const next = src.slice(k).search(/\{[%{#]/);
+        if (next === -1) {
+            valid = false;
+            k = src.length;
+            break;
+        }
+        const at = k + next;
+        const text = src.slice(k, at);
+        const e = dtlEnd(src, at);
+        if (e === -1) {
+            if (inPlural)
+                plural += src.slice(k, at + 2).replace(/%/g, '%%');
+            else
+                singular += src.slice(k, at + 2).replace(/%/g, '%%');
+            k = at + 2;
+            continue;
+        }
+        if (inPlural)
+            plural += text.replace(/%/g, '%%');
+        else
+            singular += text.replace(/%/g, '%%');
+        const token = src.slice(at, e);
+        const inner = token.slice(2, -2).trim();
+        if (token.startsWith('{{')) {
+            const piece = `%(${inner})s`;
+            if (inPlural)
+                plural += piece;
+            else
+                singular += piece;
+        }
+        else if (token.startsWith('{%')) {
+            const name = inner.split(/\s+/)[0];
+            if (name === 'plural')
+                inPlural = true;
+            else if (name === 'endblocktrans' || name === 'endblocktranslate') {
+                k = e;
+                break;
+            }
+            else {
+                valid = false; // other tags aren't allowed inside blocktranslate
+            }
+        }
+        k = e;
+    }
+    if (!valid)
+        return { msgid: '', end: k };
+    const fix = (s) => (trimmed ? trimWhitespace(s) : s);
+    void tagStart;
+    return { msgid: fix(singular), plural: isCount && inPlural ? fix(plural) : undefined, ctx, end: k };
+}