@dogsbay/format-starlight 0.2.0-beta.12 → 0.2.0-beta.121

package/dist/jsx-to-jinja.js

@@ -0,0 +1,869 @@
+/**
+ * JSX expressions over partial props → Jinja (template pages,
+ * plans/page-templates.md Phase 1).
+ *
+ * Cloudflare partials read their parameters as `props.x` inside MDX
+ * expressions: `{props.x}`, `{props.a === "b" ? "c" : props.d}`,
+ * `{props.a === "b" && (<p>…</p>)}`, `{props.x ?? "default"}`, and
+ * `href={`/x/${props.y}/`}` in attributes. This module translates the subset
+ * that corpus actually uses into Jinja:
+ *
+ *   {props.x}                    → {{ x }}
+ *   {props.x ?? "d"}             → {{ x | default("d") }}
+ *   {A ? B : C} (text position)  → {% if A %}B{% else %}C{% endif %}
+ *   {A && B}    (text position)  → {% if A %}B{% endif %}
+ *   attr={EXPR}                  → attr="{{ EXPR }}"   (or the literal text)
+ *
+ * The expression grammar is deliberately small: `props.name`, string /
+ * number / boolean literals, template literals, `=== == !== != && || ! ??`,
+ * `?:`, parentheses, and `.includes(…)`. Anything else — a function call,
+ * an arrow function, an object literal, another identifier — is REFUSED:
+ * the original `{…}` stays byte-for-byte and is counted, so a conversion
+ * never produces a plausible wrong template (the format-vitepress rule).
+ */
+export function newStats() {
+    return { converted: 0, refused: 0, refusedSamples: [], names: new Set(), markdownInlined: 0 };
+}
+class Refuse extends Error {
+}
+const OPS = ["===", "!==", "==", "!=", "&&", "||", "??", "?.", "?", ":", "!", "(", ")", ".", ","];
+function tokenize(src) {
+    const out = [];
+    let i = 0;
+    while (i < src.length) {
+        const c = src[i];
+        if (/\s/.test(c)) {
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            let j = i + 1;
+            let v = "";
+            while (j < src.length && src[j] !== c) {
+                if (src[j] === "\\" && j + 1 < src.length) {
+                    v += src[j + 1];
+                    j += 2;
+                }
+                else
+                    v += src[j++];
+            }
+            if (j >= src.length)
+                throw new Refuse("unterminated string");
+            out.push({ t: "str", v });
+            i = j + 1;
+            continue;
+        }
+        if (c === "`") {
+            const parts = [];
+            let j = i + 1;
+            let buf = "";
+            while (j < src.length && src[j] !== "`") {
+                if (src[j] === "$" && src[j + 1] === "{") {
+                    const end = matchBrace(src, j + 1);
+                    if (end < 0)
+                        throw new Refuse("unterminated ${");
+                    if (buf)
+                        parts.push(buf);
+                    buf = "";
+                    parts.push(parseExpr(src.slice(j + 2, end)));
+                    j = end + 1;
+                }
+                else if (src[j] === "\\" && j + 1 < src.length) {
+                    buf += src[j + 1];
+                    j += 2;
+                }
+                else
+                    buf += src[j++];
+            }
+            if (j >= src.length)
+                throw new Refuse("unterminated template literal");
+            if (buf)
+                parts.push(buf);
+            out.push({ t: "tpl", parts });
+            i = j + 1;
+            continue;
+        }
+        if (c === "<") {
+            // A JSX value (in a branch position): take it whole, balanced by tags.
+            const end = jsxEnd(src, i);
+            out.push({ t: "jsx", v: src.slice(i, end) });
+            i = end;
+            continue;
+        }
+        if (/[0-9]/.test(c)) {
+            const m = /^[0-9]+(\.[0-9]+)?/.exec(src.slice(i));
+            out.push({ t: "num", v: m[0] });
+            i += m[0].length;
+            continue;
+        }
+        if (/[A-Za-z_$]/.test(c)) {
+            const m = /^[A-Za-z_$][\w$]*/.exec(src.slice(i));
+            out.push({ t: "id", v: m[0] });
+            i += m[0].length;
+            continue;
+        }
+        const op = OPS.find((o) => src.startsWith(o, i));
+        if (!op)
+            throw new Refuse(`unsupported character '${c}'`);
+        out.push({ t: "op", v: op });
+        i += op.length;
+    }
+    out.push({ t: "end" });
+    return out;
+}
+/**
+ * End index (exclusive) of a JSX element or fragment starting at `i`.
+ *
+ * A tag ends at the first `>` OUTSIDE its attribute values: Cloudflare's
+ * `<Markdown text={`… **Insights** > **Network health** …`} />` carries `>`
+ * in a template literal, and ending there refused ~40 partial conditionals
+ * (their `<Markdown>` then leaked as raw tags). Braced expressions in
+ * children (`{" "}`, `{props.x}`) are skipped whole for the same reason.
+ */
+function jsxEnd(src, i) {
+    let depth = 0;
+    let j = i;
+    const skipBraced = (at) => {
+        const close = matchBrace(src, at);
+        if (close < 0)
+            throw new Refuse("unbalanced JSX expression");
+        return close + 1;
+    };
+    while (j < src.length) {
+        if (src[j] === "<") {
+            const closing = src[j + 1] === "/";
+            let k = j + 1;
+            for (;;) {
+                if (k >= src.length)
+                    throw new Refuse("unterminated JSX");
+                const ch = src[k];
+                if (ch === "{")
+                    k = skipBraced(k);
+                else if (ch === '"' || ch === "'") {
+                    const q = src.indexOf(ch, k + 1);
+                    if (q < 0)
+                        throw new Refuse("unterminated JSX attribute");
+                    k = q + 1;
+                }
+                else if (ch === ">")
+                    break;
+                else
+                    k++;
+            }
+            const selfClosing = src[k - 1] === "/";
+            if (closing)
+                depth--;
+            else if (!selfClosing)
+                depth++;
+            j = k + 1;
+            if (depth === 0)
+                return j;
+            continue;
+        }
+        if (depth === 0)
+            break;
+        if (src[j] === "{") {
+            j = skipBraced(j);
+            continue;
+        }
+        j++;
+    }
+    if (depth !== 0)
+        throw new Refuse("unbalanced JSX");
+    return j;
+}
+/** `bare`: identifiers that ARE props (a component's own destructured names), read as `props.<name>`. */
+function parseExpr(src, bare) {
+    const toks = tokenize(src);
+    let p = 0;
+    const peek = () => toks[p];
+    const isOp = (v) => peek().t === "op" && peek().v === v;
+    const eat = (v) => {
+        if (!isOp(v))
+            throw new Refuse(`expected '${v}'`);
+        p++;
+    };
+    const primary = () => {
+        const t = toks[p++];
+        switch (t.t) {
+            case "str":
+                return { k: "str", v: t.v };
+            case "num":
+                return { k: "num", v: t.v };
+            case "tpl":
+                return { k: "tpl", parts: t.parts };
+            case "jsx":
+                return { k: "jsx", v: t.v };
+            case "id": {
+                if (t.v === "true" || t.v === "false")
+                    return { k: "bool", v: t.v === "true" };
+                if (t.v === "null" || t.v === "undefined")
+                    return { k: "none" };
+                if (bare?.has(t.v)) {
+                    if (isOp(".") || isOp("?.") || isOp("("))
+                        throw new Refuse("member access or call on a prop");
+                    return { k: "prop", name: t.v };
+                }
+                // A component template has no `props` of its own: its names are `bare`.
+                if (t.v !== "props" || bare)
+                    throw new Refuse(`identifier '${t.v}'`);
+                if (!(isOp(".") || isOp("?.")))
+                    throw new Refuse("bare props");
+                p++;
+                const name = toks[p++];
+                if (name.t !== "id")
+                    throw new Refuse("props.<name>");
+                let e = { k: "prop", name: name.v };
+                // props.x.includes(y) → y in x
+                if ((isOp(".") || isOp("?.")) && toks[p + 1]?.t === "id" && toks[p + 1].v === "includes") {
+                    p += 2;
+                    eat("(");
+                    const needle = expr();
+                    eat(")");
+                    e = { k: "in", needle, hay: e };
+                }
+                if (isOp(".") || isOp("?.") || isOp("("))
+                    throw new Refuse("member access or call beyond props.<name>");
+                return e;
+            }
+            case "op":
+                if (t.v === "(") {
+                    const e = expr();
+                    eat(")");
+                    return e;
+                }
+                if (t.v === "!")
+                    return { k: "not", e: primary() };
+        }
+        throw new Refuse("unexpected token");
+    };
+    const equality = () => {
+        let l = primary();
+        while (isOp("===") || isOp("==") || isOp("!==") || isOp("!=")) {
+            const op = toks[p++].v.startsWith("!") ? "!=" : "==";
+            l = { k: "bin", op, l, r: primary() };
+        }
+        return l;
+    };
+    const and = () => {
+        let l = equality();
+        while (isOp("&&")) {
+            p++;
+            l = { k: "bin", op: "and", l, r: equality() };
+        }
+        return l;
+    };
+    const or = () => {
+        let l = and();
+        while (isOp("||") || isOp("??")) {
+            const op = toks[p++].v === "??" ? "default" : "or";
+            l = { k: "bin", op, l, r: and() };
+        }
+        return l;
+    };
+    function expr() {
+        const test = or();
+        if (isOp("?")) {
+            p++;
+            const then = expr();
+            eat(":");
+            return { k: "cond", test, then, else: expr() };
+        }
+        return test;
+    }
+    const e = expr();
+    if (peek().t !== "end")
+        throw new Refuse("trailing input");
+    return e;
+}
+// ─── Jinja emission ───────────────────────────────────────────────────────
+/**
+ * A Jinja string literal that needs no backslash escape for quotes.
+ *
+ * The directive text passes through the Markdown parser before it reaches
+ * the template engine, and Markdown reads `\"` as an escaped quote — it
+ * drops the backslash, and `"a \"b\" c"` arrived as `"a "b" c"`, a syntax
+ * error (the first Cloudflare conversion run failed on exactly this). So a
+ * value is quoted with whichever quote it does not contain, or split and
+ * joined with `~` when it contains both. Newlines and tabs stay `\n`/`\t`:
+ * Markdown leaves a backslash before a letter alone. A literal backslash
+ * cannot be written safely at all, so it is refused.
+ */
+function jinjaString(v) {
+    if (v.includes("\\"))
+        throw new Refuse("a backslash in a string value");
+    const body = (x) => x.replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
+    if (!v.includes('"'))
+        return `"${body(v)}"`;
+    if (!v.includes("'"))
+        return `'${body(v)}'`;
+    return v.split('"').map((part) => `"${body(part)}"`).join(` ~ '"' ~ `);
+}
+/** A value expression in Jinja source. JSX values are not values. */
+function value(e, names) {
+    switch (e.k) {
+        case "prop":
+            names.add(e.name);
+            return e.name;
+        case "str":
+            return jinjaString(e.v);
+        case "num":
+            return e.v;
+        case "bool":
+            return e.v ? "true" : "false";
+        case "none":
+            return "none";
+        case "tpl":
+            return e.parts.length === 0 ? '""' : e.parts.map((x) => (typeof x === "string" ? jinjaString(x) : `(${value(x, names)})`)).join(" ~ ");
+        case "not":
+            return `not (${value(e.e, names)})`;
+        case "in":
+            return `(${value(e.needle, names)}) in (${value(e.hay, names)})`;
+        case "bin":
+            if (e.op === "default")
+                return `(${value(e.l, names)}) | default(${value(e.r, names)})`;
+            return `(${value(e.l, names)}) ${e.op} (${value(e.r, names)})`;
+        case "cond":
+            return `(${value(e.then, names)}) if (${value(e.test, names)}) else (${value(e.else, names)})`;
+        case "jsx":
+            throw new Refuse("JSX in a value position");
+    }
+}
+/** A directive's source, as a token when a table is in use. */
+function emit(src, stats) {
+    return stats.table ? stats.table.token(src) : src;
+}
+/** Output for a branch of a text-position conditional: literal text, JSX (converted recursively), or a value. */
+function branch(e, stats, layout) {
+    if (e.k === "str")
+        return e.v;
+    if (e.k === "jsx") {
+        const inner = e.v.startsWith("<>") && e.v.endsWith("</>") ? e.v.slice(2, -3) : e.v;
+        const converted = convertText(layout.block ? dedent(inner) : inner, stats);
+        return layout.block ? converted.replace(/^\s*\n|\n\s*$/g, "") : converted;
+    }
+    if (e.k === "cond")
+        return statement(e, stats, layout);
+    if (e.k === "bin" && e.op === "and" && (e.r.k === "jsx" || e.r.k === "str"))
+        return statement(e, stats, layout);
+    return emit(`{{ ${value(e, stats.names)} }}`, stats);
+}
+/**
+ * Remove the common leading indentation of a JSX branch body. In JSX it
+ * means nothing; in Markdown four spaces make an indented CODE block, and a
+ * branch of `<strong>`/`<ul>` markup came out as a `plaintext` code sample.
+ */
+function dedent(s) {
+    const lines = s.split("\n");
+    // The first line is left out of the minimum: it follows `(` or `&&` on
+    // the expression's own line, so its column says nothing about the body's
+    // (`{props.a && (<div>\n        body` must still lose the 8).
+    const widths = lines.slice(1).filter((l) => l.trim()).map((l) => /^[ \t]*/.exec(l)[0].length);
+    const min = widths.length ? Math.min(...widths) : 0;
+    return min ? lines.map((l) => l.slice(Math.min(min, /^[ \t]*/.exec(l)[0].length))).join("\n") : s;
+}
+/**
+ * A text-position expression: `{% if %}` for conditionals, `{{ }}` for
+ * values. A block (multi-line) conditional puts each directive on its own
+ * line with blank lines around it, at the expression's indent — so no
+ * Markdown block (an HTML block, an unmapped component) can swallow the
+ * `{% endif %}` that follows its body.
+ */
+function statement(e, stats, layout) {
+    const sep = layout.block ? `\n\n${layout.indent}` : "";
+    const d = (src) => `${sep}${emit(src, stats)}${sep}`;
+    // No whitespace control: a conditional on a list or tab marker line is
+    // handled after rendering (TemplatePages joins an emptied marker line with
+    // its content). Trimming after the tags ate the NEXT line's indent whenever
+    // a conditional rendered nothing, and a tabs closer lost column 0.
+    if (e.k === "cond") {
+        const tail = e.else.k === "cond" ? `${d("{% else %}")}${statement(e.else, stats, layout)}` : `${d("{% else %}")}${branch(e.else, stats, layout)}`;
+        return `${d(`{% if ${value(e.test, stats.names)} %}`)}${branch(e.then, stats, layout)}${tail}${d("{% endif %}")}`;
+    }
+    if (e.k === "bin" && e.op === "and" && (e.r.k === "jsx" || e.r.k === "str")) {
+        return `${d(`{% if ${value(e.l, stats.names)} %}`)}${branch(e.r, stats, layout)}${d("{% endif %}")}`;
+    }
+    return emit(`{{ ${value(e, stats.names)} }}`, stats);
+}
+/** An attribute value: literal text when constant, else a `{{ }}` in quotes. */
+function attribute(e, stats) {
+    const names = stats.names;
+    if (e.k === "str")
+        return JSON.stringify(e.v);
+    if (e.k === "tpl" && e.parts.every((x) => typeof x === "string"))
+        return JSON.stringify(e.parts.join(""));
+    if (e.k === "tpl") {
+        return JSON.stringify(e.parts.map((x) => (typeof x === "string" ? x : emit(`{{ ${value(x, names)} }}`, stats))).join(""));
+    }
+    return JSON.stringify(emit(`{{ ${value(e, names)} }}`, stats));
+}
+/**
+ * Cloudflare's `<Markdown text={…} />` renders its text as Markdown. When the
+ * text is a string or template literal (the partials' shape), the tag is
+ * replaced by the text itself, dedented, with `${props.x}` as `{{ x }}`.
+ * Unmapped, it was dropped in both import modes. Returns undefined when the
+ * tag is not that shape.
+ */
+function markdownTag(src, at, stats) {
+    // `text="…"` (a plain attribute): its value IS the Markdown. Only the
+    // braced form was read, so `{ !props.x && <Markdown text="…" /> }` leaked.
+    const quoted = /^<Markdown\s+text=(?:"([^"]*)"|'([^']*)')((?:\s+[\w:-]+(?:=(?:"[^"]*"|'[^']*'|\{[^{}]*\}))?)*)\s*\/>/.exec(src.slice(at));
+    if (quoted) {
+        stats.markdownInlined++;
+        return { end: at + quoted[0].length, text: (quoted[1] ?? quoted[2]).trim() };
+    }
+    const head = /^<Markdown\s+text=\{/.exec(src.slice(at));
+    if (!head)
+        return undefined;
+    const open = at + head[0].length - 1;
+    const close = matchBrace(src, open);
+    if (close < 0)
+        return undefined;
+    const tagEnd = src.indexOf("/>", close);
+    if (tagEnd < 0 || /[<>]/.test(src.slice(close + 1, tagEnd)))
+        return undefined;
+    let e;
+    try {
+        e = parseExpr(src.slice(open + 1, close));
+    }
+    catch (err) {
+        if (err instanceof Refuse)
+            return undefined;
+        throw err;
+    }
+    // `text={props.x}` (and `props.x || ""`): the parameter's own Markdown, as
+    // a value. It is Markdown already, and the rendered page is parsed as
+    // Markdown, so `{{ x }}` renders as the component did. 150+ of these leaked
+    // as raw tags in partials.
+    if (e.k !== "str" && e.k !== "tpl") {
+        // Only what prints TEXT: a prop, or `a || "b"` / `a ?? "b"`. `a && b` and
+        // comparisons would print `false`/`true` (Jinja returns the operand).
+        const printsText = (x) => x.k === "prop" || x.k === "str" || (x.k === "bin" && (x.op === "or" || x.op === "default") && printsText(x.l) && printsText(x.r));
+        if (!printsText(e))
+            return undefined;
+        let v;
+        try {
+            v = value(e, stats.names);
+        }
+        catch (err) {
+            if (err instanceof Refuse)
+                return undefined;
+            throw err;
+        }
+        stats.markdownInlined++;
+        return { end: tagEnd + 2, text: emit(`{{ ${v} }}`, stats) };
+    }
+    const raw = e.k === "str" ? e.v : e.parts.map((x) => (typeof x === "string" ? x : emit(`{{ ${value(x, stats.names)} }}`, stats))).join("");
+    const lines = raw.replace(/^\n+|\s+$/g, "").split("\n");
+    const indent = Math.min(...lines.filter((l) => l.trim()).map((l) => /^\s*/.exec(l)[0].length));
+    // A tag on its own indented line (inside a JSX branch): its continuation
+    // lines take that indent too, as the first line does by standing after it.
+    // At column 0 they broke the branch dedent — a table's first row kept a
+    // tab, its other rows had none, and the table was lost.
+    const lineStart = src.lastIndexOf("\n", at - 1) + 1;
+    const lead = /^[ \t]*$/.test(src.slice(lineStart, at)) ? src.slice(lineStart, at) : "";
+    stats.markdownInlined++;
+    return {
+        end: tagEnd + 2,
+        text: lines.map((l, n) => (n && l.trim() ? lead : "") + l.slice(Number.isFinite(indent) ? indent : 0)).join("\n"),
+    };
+}
+// ─── Scanning the MDX body ────────────────────────────────────────────────
+/** Index of the `}` matching the `{` at `open`, skipping strings, template literals and JSX values. */
+function matchBrace(src, open) {
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        const c = src[i];
+        // Comments: `{/* note, <Aside> below */}` is not JSX, and `{/* don't */}`
+        // has no string in it.
+        if (c === "/" && src[i + 1] === "*") {
+            const end = src.indexOf("*/", i + 2);
+            if (end < 0)
+                return -1;
+            i = end + 1;
+            continue;
+        }
+        if (c === "/" && src[i + 1] === "/" && i > open) {
+            const nl = src.indexOf("\n", i);
+            if (nl < 0)
+                return -1;
+            i = nl;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === "`") {
+            const q = c;
+            i++;
+            while (i < src.length && src[i] !== q) {
+                if (src[i] === "\\")
+                    i++;
+                else if (q === "`" && src[i] === "$" && src[i + 1] === "{") {
+                    const end = matchBrace(src, i + 1);
+                    if (end < 0)
+                        return -1;
+                    i = end;
+                }
+                i++;
+            }
+            continue;
+        }
+        // JSX in a value position (`&& (<>…</>)`, `? <p>…</p> :`): its TEXT is
+        // not JavaScript. An apostrophe there ("Cloudflare's") was read as a
+        // string opener, the brace never closed, and the rest of the partial was
+        // copied through unconverted (its `<Markdown>`/`<AnchorHeading>` leaked).
+        if (c === "<" && /[A-Za-z>]/.test(src[i + 1] ?? "") && /[(?:,&|{[]$/.test(src.slice(open, i).trimEnd())) {
+            try {
+                i = jsxEnd(src, i) - 1;
+            }
+            catch {
+                return -1;
+            }
+            continue;
+        }
+        if (c === "{")
+            depth++;
+        else if (c === "}") {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Convert every `{…}` over props in a text span (no code fences). Inline code
+ * spans are skipped: `{props.x}` inside backticks is literal in MDX too.
+ * `<Render …/>` tags are left alone — their `params={{…}}` belong to the
+ * Render conversion.
+ */
+function convertText(src, stats) {
+    let out = "";
+    let i = 0;
+    while (i < src.length) {
+        const c = src[i];
+        if (c === "`") {
+            const run = /^`+/.exec(src.slice(i))[0];
+            const close = src.indexOf(run, i + run.length);
+            if (close < 0) {
+                out += src.slice(i);
+                break;
+            }
+            out += src.slice(i, close + run.length);
+            i = close + run.length;
+            continue;
+        }
+        if (src.startsWith("<Markdown", i)) {
+            const md = markdownTag(src, i, stats);
+            if (md) {
+                out += md.text;
+                i = md.end;
+                continue;
+            }
+        }
+        if (src.startsWith("<Render", i)) {
+            const end = src.indexOf("/>", i);
+            if (end >= 0) {
+                out += src.slice(i, end + 2);
+                i = end + 2;
+                continue;
+            }
+        }
+        if (c !== "{") {
+            out += c;
+            i++;
+            continue;
+        }
+        const close = matchBrace(src, i);
+        if (close < 0) {
+            out += src.slice(i);
+            break;
+        }
+        const whole = src.slice(i, close + 1);
+        const inner = whole.slice(1, -1);
+        if (!/\bprops\b/.test(inner) || inner.trim().startsWith("/*")) {
+            out += whole;
+            i = close + 1;
+            continue;
+        }
+        // Attribute position: `name={…}` inside an open JSX tag (`<a href={…}`).
+        // Prose like `CLOUDFLARE_ACCOUNT_ID={props.id}` is NOT an attribute: it
+        // would gain literal quotes the source never rendered.
+        const inTag = /<[A-Za-z][^<>]*$/.test(out);
+        const attr = inTag ? /([A-Za-z_:][\w:.-]*)\s*=\s*$/.exec(out) : null;
+        try {
+            const e = parseExpr(inner);
+            if (attr) {
+                out = out.slice(0, out.length - attr[0].length) + `${attr[1]}=` + attribute(e, stats);
+            }
+            else {
+                const lineStart = out.lastIndexOf("\n") + 1;
+                const indent = /^[ \t]*/.exec(out.slice(lineStart))[0];
+                // A conditional alone on its line with a JSX branch is a BLOCK too:
+                // `{ props.p === "x" && <><AnchorHeading … /></> }` kept its heading
+                // glued between `{% if %}` and `{% endif %}`, where it could not be
+                // a heading and leaked as a tag.
+                const alone = out.slice(lineStart) === indent && /^[ \t]*(\n|$)/.test(src.slice(close + 1));
+                // Only a BLOCK-level branch: `<Markdown text={`- item`}>` after a list
+                // item, or `<em>` mid-paragraph, must stay on the line (blank lines
+                // made the list loose and split the paragraph — review).
+                const blockJsx = /^(?:<>\s*)?<(?:AnchorHeading|Aside|Details|Tabs|Steps|CardGrid|LinkTitleCard|LinkCard|LinkButton|Card|Code|h[1-6]|table|ul|ol|div)\b/;
+                const jsxBranch = (x) => (x.k === "jsx" && blockJsx.test(x.v.trim())) ||
+                    (x.k === "bin" && x.op === "and" && jsxBranch(x.r)) ||
+                    (x.k === "cond" && (jsxBranch(x.then) || jsxBranch(x.else)));
+                out += statement(e, stats, { block: inner.includes("\n") || (alone && jsxBranch(e)), indent });
+            }
+            stats.converted++;
+        }
+        catch (err) {
+            if (!(err instanceof Refuse))
+                throw err;
+            stats.refused++;
+            if (stats.refusedSamples.length < 20)
+                stats.refusedSamples.push(whole.replace(/\s+/g, " ").slice(0, 160));
+            out += whole;
+        }
+        i = close + 1;
+    }
+    return out;
+}
+/**
+ * Convert a partial's MDX body. Fenced code blocks are copied verbatim;
+ * everything else goes through `convertText`.
+ */
+export function jsxPropsToJinja(body, stats) {
+    // Directive tokens are restored in the tree (template-tokens.ts).
+    const lines = body.split("\n");
+    const out = [];
+    let fence = null;
+    let buf = [];
+    const flush = () => {
+        if (buf.length)
+            out.push(convertText(buf.join("\n"), stats));
+        buf = [];
+    };
+    for (const line of lines) {
+        const m = /^\s*(`{3,}|~{3,})/.exec(line);
+        if (fence) {
+            out.push(line);
+            if (m && m[1][0] === fence[0] && m[1].length >= fence.length && line.trim() === m[1])
+                fence = null;
+            continue;
+        }
+        if (m) {
+            flush();
+            fence = m[1];
+            out.push(line);
+            continue;
+        }
+        buf.push(line);
+    }
+    flush();
+    return out.join("\n");
+}
+/**
+ * A JS literal from `params={{ … }}` as a Jinja expression, or undefined when
+ * it is outside the subset (the caller then inlines the partial as before).
+ */
+export function jsValueToJinja(src, names) {
+    try {
+        const trimmed = src.trim();
+        // Arrays of literals: ["a", "b"] → ["a", "b"]
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            const items = splitTopLevel(trimmed.slice(1, -1));
+            const vals = items.filter((x) => x.trim()).map((x) => jsValueToJinja(x, names));
+            return vals.some((v) => v === undefined) ? undefined : `[${vals.join(", ")}]`;
+        }
+        const e = parseExpr(trimmed);
+        if (e.k === "jsx")
+            return undefined;
+        return value(e, names ?? new Set());
+    }
+    catch (err) {
+        if (err instanceof Refuse)
+            return undefined;
+        throw err;
+    }
+}
+/** Split `a, b, "c, d"` at top-level commas (strings, brackets and braces respected). */
+export function splitTopLevel(src) {
+    const parts = [];
+    let depth = 0;
+    let cur = "";
+    let q = null;
+    for (let i = 0; i < src.length; i++) {
+        const c = src[i];
+        if (q) {
+            cur += c;
+            if (c === "\\")
+                cur += src[++i] ?? "";
+            else if (c === q)
+                q = null;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === "`")
+            q = c;
+        else if (c === "{" || c === "[" || c === "(")
+            depth++;
+        else if (c === "}" || c === "]" || c === ")")
+            depth--;
+        else if (c === "," && depth === 0) {
+            parts.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += c;
+    }
+    if (cur.trim())
+        parts.push(cur);
+    return parts;
+}
+// ─── Static rendering of a component template ─────────────────────────────
+/**
+ * Render an Astro component's TEMPLATE for known props — read, never run:
+ * `{cond && (<p>…</p>)}`, `{a === "x" ? (A) : (B)}`, `attr={cond ? "a" : "b"}`,
+ * `{"text"}`, fragments, comments — the JS subset `parseExpr` reads, with
+ * the component's own prop names (`cli`, not `props.cli`). `inline` may
+ * replace a self-closing sub-component with its own rendering. Undefined
+ * when anything is outside the subset (the caller leaves the tag reported).
+ */
+export function renderComponentTemplate(template, props, inline) {
+    // Prop names are resolved by the TOKENIZER (a regex rename also rewrote
+    // the word in a JSX branch's text).
+    const names = new Set(Object.keys(props));
+    const truthy = (v) => !(v === undefined || v === null || v === false || v === 0 || v === "");
+    const evalExpr = (e) => {
+        switch (e.k) {
+            case "prop":
+                return props[e.name];
+            case "str":
+                return e.v;
+            case "num":
+                return Number(e.v);
+            case "bool":
+                return e.v;
+            case "none":
+                return undefined;
+            case "tpl":
+                return e.parts.map((x) => (typeof x === "string" ? x : String(evalExpr(x) ?? ""))).join("");
+            case "jsx":
+                return { jsx: e.v };
+            case "not":
+                return !truthy(evalExpr(e.e));
+            case "in": {
+                const hay = evalExpr(e.hay);
+                return Array.isArray(hay) || typeof hay === "string" ? hay.includes(evalExpr(e.needle)) : false;
+            }
+            case "cond":
+                return truthy(evalExpr(e.test)) ? evalExpr(e.then) : evalExpr(e.else);
+            case "bin": {
+                const l = evalExpr(e.l);
+                if (e.op === "and")
+                    return truthy(l) ? evalExpr(e.r) : l;
+                if (e.op === "or")
+                    return truthy(l) ? l : evalExpr(e.r);
+                if (e.op === "default")
+                    return l ?? evalExpr(e.r);
+                const r = evalExpr(e.r);
+                return e.op === "==" ? l === r : l !== r;
+            }
+        }
+    };
+    const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+    const render = (src, depth) => {
+        if (depth > 8)
+            throw new Refuse("nesting");
+        let out = "";
+        let i = 0;
+        while (i < src.length) {
+            const c = src[i];
+            if (c !== "{") {
+                out += c;
+                i++;
+                continue;
+            }
+            const close = matchBrace(src, i);
+            if (close < 0)
+                throw new Refuse("unbalanced");
+            const inner = src.slice(i + 1, close).trim();
+            i = close + 1;
+            if (/^\/\*[\s\S]*\*\/$/.test(inner))
+                continue;
+            const attr = /(?:^|\s)([A-Za-z_:][\w:.-]*)\s*=\s*$/.exec(out);
+            // Inside an open tag, quoted values skipped (a `>` in `title="a>b"` is not the tag's end).
+            const inTag = /<[A-Za-z][\w:.-]*(?:\s+[^\s"'<>=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'))?)*\s+[^\s"'<>=]+\s*=\s*$/.test(out);
+            if (attr && !inTag && /<[A-Za-z][^<]*$/.test(out))
+                throw new Refuse("attribute position unclear");
+            const v = evalExpr(parseExpr(inner, names));
+            if (inTag && attr) {
+                // A falsy value drops the attribute, and the space before it.
+                if (attr[1].startsWith("set:"))
+                    throw new Refuse("set: directive");
+                const sep = /^\s/.test(attr[0]) ? " " : "";
+                out = out.slice(0, out.length - attr[0].length);
+                // Astro drops an attribute only for false, null and undefined (0 and "" render).
+                if (v === true)
+                    out += sep + attr[1];
+                else if (v !== false && v !== null && v !== undefined) {
+                    if (typeof v === "object")
+                        throw new Refuse("object attribute");
+                    out += `${sep}${attr[1]}="${String(v).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;")}"`;
+                }
+                continue;
+            }
+            if (v && typeof v === "object" && "jsx" in v) {
+                const jsx = String(v.jsx).replace(/^<>/, "").replace(/<\/>$/, "");
+                out += render(jsx, depth + 1);
+            }
+            else if (typeof v === "string" || typeof v === "number")
+                out += esc(String(v));
+        }
+        return out;
+    };
+    let html;
+    try {
+        html = render(template, 0);
+    }
+    catch (err) {
+        if (err instanceof Refuse)
+            return undefined;
+        throw err;
+    }
+    html = html.replace(/<\/?>/g, "");
+    if (!inline)
+        return html;
+    const tagRe = /<([A-Z]\w*)\b((?:[^<>"'{]|"[^"]*"|'[^']*'|\{[^{}]*\})*)\/>/g;
+    html = html.replace(tagRe, (whole, tag, attrStr) => {
+        const attrs = {};
+        for (const m of attrStr.matchAll(/([\w:-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'))?/g))
+            attrs[m[1]] = m[2] ?? m[3] ?? true;
+        const r = inline(tag, attrs);
+        if (r === undefined)
+            return whole;
+        return r;
+    });
+    return html;
+}
+/** `const { a, b = false } = Astro.props;` → the prop names and their defaults (literals only). */
+export function componentPropDefaults(frontmatter) {
+    const m = /const\s*\{([^}]*)\}\s*=\s*Astro\.props/.exec(frontmatter);
+    if (!m)
+        return {};
+    const out = {};
+    for (const part of splitTopLevel(m[1])) {
+        const eq = part.indexOf("=");
+        const name = (eq < 0 ? part : part.slice(0, eq)).trim();
+        const def = eq < 0 ? undefined : part.slice(eq + 1).trim();
+        if (!/^\w+$/.test(name))
+            return undefined;
+        if (def === undefined) {
+            out[name] = undefined;
+            continue;
+        }
+        // A default it cannot read makes the whole component unreadable: a
+        // guessed `undefined` would render the wrong branch silently.
+        const lit = def === "false" ? false : def === "true" ? true : def === "null" ? null : /^"[^"]*"$|^'[^']*'$/.test(def) ? def.slice(1, -1) : /^-?\d+(\.\d+)?$/.test(def) ? Number(def) : Symbol.for("unreadable");
+        if (typeof lit === "symbol")
+            return undefined;
+        out[name] = lit;
+    }
+    return out;
+}