@speajus/markdown-to-pdf 1.0.4 → 1.0.6

package/dist/renderer.js

@@ -0,0 +1,718 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdownToPdf = renderMarkdownToPdf;
+const styles_js_1 = require("./styles.js");
+const pdfkit_1 = __importDefault(require("pdfkit"));
+const marked_1 = require("marked");
+const stream_1 = require("stream");
+const defaults_js_1 = require("./defaults.js");
+const highlight_prism_js_1 = require("./highlight.prism.js");
+const emoji_js_1 = require("./emoji.js");
+const color_emoji_js_1 = require("./color-emoji.js");
+/** Name used to register the emoji font with PDFKit */
+const EMOJI_FONT_NAME = 'NotoEmoji';
+async function renderMarkdownToPdf(markdown, options) {
+    const theme = options?.theme ?? styles_js_1.defaultTheme;
+    const layout = options?.pageLayout ?? styles_js_1.defaultPageLayout;
+    const basePath = options?.basePath ?? '';
+    const syntaxHighlight = options?.syntaxHighlight !== false;
+    if (syntaxHighlight) {
+        (0, highlight_prism_js_1.loadHighlightLanguages)(options?.languages);
+    }
+    const emojiFontOpt = options?.emojiFont ?? true;
+    // Use provided image renderer or create default Node.js renderer
+    const imageRenderer = options?.renderImage ?? defaults_js_1.DEFAULTS.renderImage(basePath);
+    const { margins } = layout;
+    const doc = new pdfkit_1.default({ size: layout.pageSize, margins });
+    const stream = new stream_1.PassThrough();
+    const chunks = [];
+    doc.pipe(stream);
+    stream.on('data', (chunk) => chunks.push(chunk));
+    // ── Emoji font registration ───────────────────────────────────────────────
+    // The font registration block uses dynamic require() for `path` and `fs` so
+    // that the renderer module can also be imported in browser environments where
+    // those Node.js built-ins are unavailable.  If they aren't available the
+    // try/catch simply falls through and emoji support is disabled (unless the
+    // caller passes a Buffer directly via the `emojiFont` option).
+    let emojiEnabled = false;
+    if (emojiFontOpt !== false) {
+        try {
+            if (Buffer.isBuffer(emojiFontOpt)) {
+                // Raw font data — works in both Node.js and browser environments.
+                doc.registerFont(EMOJI_FONT_NAME, emojiFontOpt);
+                emojiEnabled = true;
+            }
+            else {
+                // Resolve a file path — requires Node.js built-ins.
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const nodePath = require('path');
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const nodeFs = require('fs');
+                const fontPath = typeof emojiFontOpt === 'string'
+                    ? emojiFontOpt
+                    : nodePath.join(__dirname, 'fonts', 'NotoEmoji-Regular.ttf');
+                if (nodeFs.existsSync(fontPath)) {
+                    doc.registerFont(EMOJI_FONT_NAME, fontPath);
+                    emojiEnabled = true;
+                }
+            }
+        }
+        catch {
+            // Font registration failed or Node.js APIs not available (browser) —
+            // fall through without emoji support.
+        }
+    }
+    // ── Color emoji pre-render ─────────────────────────────────────────────
+    // When a colorEmoji renderer is provided, pre-scan the entire markdown for
+    // every unique emoji and convert them all to PNG buffers up-front.  This
+    // lets `renderTextWithEmoji` remain synchronous during page rendering.
+    let emojiImageCache;
+    const colorEmojiEnabled = !!options?.colorEmoji;
+    if (options?.colorEmoji) {
+        emojiImageCache = await (0, color_emoji_js_1.preRenderEmoji)(markdown, options.colorEmoji, (0, emoji_js_1.getEmojiRegex)());
+    }
+    const tokens = marked_1.marked.lexer(markdown);
+    const contentWidth = doc.page.width - margins.left - margins.right;
+    // ── Table cell context ──────────────────────────────────────────────────
+    // When rendering inline tokens inside a table cell, the first text output
+    // must be positioned at the cell's (x, y) with the cell's width/align.
+    // Subsequent text outputs in the same cell use PDFKit's continued-flow.
+    let cellCtx = null;
+    // ── Heading context ───────────────────────────────────────────────────
+    // When rendering inline tokens inside a heading, font helpers use the
+    // heading's style (font, fontSize, color) instead of the body style.
+    let headingCtx = null;
+    function ensureSpace(needed) {
+        if (doc.y + needed > doc.page.height - margins.bottom) {
+            doc.addPage();
+        }
+    }
+    /** Derive the italic variant of a PDFKit built-in font name. */
+    function italicVariant(font) {
+        if (font.startsWith('Times'))
+            return font.replace(/-Bold$/, '-BoldItalic').replace(/^Times-Roman$/, 'Times-Italic');
+        // Helvetica / Courier families use "Oblique"
+        if (font.endsWith('-Bold'))
+            return font + 'Oblique';
+        return font + '-Oblique';
+    }
+    function applyBodyFont(bold, italic) {
+        if (headingCtx) {
+            // Inside a heading — use heading style as the base.
+            let font = headingCtx.font;
+            if (italic)
+                font = italicVariant(font);
+            doc.font(font).fontSize(headingCtx.fontSize).fillColor(headingCtx.color);
+            return;
+        }
+        let font = theme.body.font;
+        if (bold && italic)
+            font = 'Helvetica-BoldOblique';
+        else if (bold)
+            font = 'Helvetica-Bold';
+        else if (italic)
+            font = 'Helvetica-Oblique';
+        doc.font(font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+    }
+    function resetBodyFont() {
+        if (headingCtx) {
+            doc.font(headingCtx.font).fontSize(headingCtx.fontSize).fillColor(headingCtx.color);
+            return;
+        }
+        doc.font(theme.body.font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+    }
+    /**
+     * Render a text string switching to the emoji font for emoji characters.
+     *
+     * Preserves the caller's current font / fontSize / fillColor for the
+     * non-emoji portions.  The `continued` flag behaves exactly like the
+     * native PDFKit option — pass `true` to keep the line open.
+     *
+     * When `colorEmojiEnabled` is true and `emojiImageCache` is populated,
+     * emoji characters are rendered as inline PNG images instead of font
+     * glyphs, with manual (x, y) positioning to keep them in the text flow.
+     *
+     * Supports both `renderTextWithEmoji(text, opts?)` and the positioned
+     * form `renderTextWithEmoji(text, x, y, opts?)` used by table cells.
+     */
+    function renderTextWithEmoji(text, xOrOpts, yOrUndefined, posOpts) {
+        // Normalise the two call signatures into a single (opts, firstX, firstY).
+        let opts;
+        let firstX;
+        let firstY;
+        if (typeof xOrOpts === 'number') {
+            firstX = xOrOpts;
+            firstY = yOrUndefined;
+            opts = posOpts ?? {};
+        }
+        else {
+            opts = xOrOpts ?? {};
+        }
+        // If inside a table cell and this is the first text output, apply cell positioning.
+        if (cellCtx && !cellCtx.used && firstX === undefined) {
+            firstX = cellCtx.x;
+            firstY = cellCtx.y;
+            opts = { ...opts, width: cellCtx.width, align: cellCtx.align };
+            cellCtx.used = true;
+        }
+        const hasEmoji = (0, emoji_js_1.containsEmoji)(text);
+        // ── Fast path: no emoji handling needed ──────────────────────────────
+        if ((!emojiEnabled && !colorEmojiEnabled) || !hasEmoji) {
+            if (firstX !== undefined) {
+                doc.text(text, firstX, firstY, opts);
+            }
+            else {
+                doc.text(text, opts);
+            }
+            return;
+        }
+        // Remember the caller's font state so we can restore after emoji runs.
+        const prevFont = doc._font?.name ?? theme.body.font;
+        const prevSize = doc._fontSize ?? theme.body.fontSize;
+        const segments = (0, emoji_js_1.splitEmojiSegments)(text);
+        // ── Color emoji path: render emoji as inline PNG images ──────────────
+        // Strategy: two-pass rendering.
+        //   Pass 1 – Render all text through doc.text() with `continued`,
+        //            exactly like the monochrome path.  For emoji segments,
+        //            render a space-placeholder to reserve width.  Read the
+        //            real X position from PDFKit's internal wrapper state
+        //            (_wrapper.startX + _wrapper.continuedX) — doc.x stays
+        //            at the left margin after continued:true so it is NOT
+        //            usable for positioning.
+        //   Pass 2 – Overlay emoji PNG images at the recorded positions.
+        if (colorEmojiEnabled && emojiImageCache && emojiImageCache.size > 0) {
+            const emojiRe = (0, emoji_js_1.getEmojiRegex)();
+            const emojiSize = prevSize; // match font size
+            const emojiPlacements = [];
+            // Read the actual text-flow X from PDFKit's internal LineWrapper.
+            // After doc.text(…, {continued:true}), _wrapper.continuedX tracks
+            // cumulative rendered width; startX is the original doc.x at
+            // wrapper creation time.
+            const getFlowX = () => {
+                const w = doc._wrapper;
+                if (w)
+                    return w.startX + w.continuedX;
+                return firstX ?? doc.x;
+            };
+            // Build a space-placeholder string whose width ≈ emojiSize.
+            doc.font(prevFont).fontSize(prevSize);
+            const spaceW = doc.widthOfString(' ');
+            const spacesPerEmoji = Math.max(1, Math.round(emojiSize / spaceW));
+            const placeholder = ' '.repeat(spacesPerEmoji);
+            const placeholderW = doc.widthOfString(placeholder);
+            // Vertical alignment: centre emoji within the current line height.
+            const lineH = doc.currentLineHeight(true);
+            const yOffset = Math.max(0, (lineH - emojiSize) / 2);
+            // Only use explicit (firstX, firstY) coordinates on the very first
+            // doc.text() call, and only when no wrapper already exists (i.e.
+            // we are not continuing from a prior renderTextWithEmoji call).
+            let usedExplicitCoords = false;
+            for (let i = 0; i < segments.length; i++) {
+                const seg = segments[i];
+                const isLast = i === segments.length - 1;
+                const cont = isLast ? !!opts.continued : true;
+                if (seg.isEmoji) {
+                    emojiRe.lastIndex = 0;
+                    let em;
+                    while ((em = emojiRe.exec(seg.text)) !== null) {
+                        const png = emojiImageCache.get(em[0]);
+                        const isLastEmoji = isLast && emojiRe.lastIndex >= seg.text.length;
+                        const eCont = isLastEmoji ? !!opts.continued : true;
+                        if (png) {
+                            // Position BEFORE rendering the placeholder.
+                            const emojiX = getFlowX();
+                            // For positioned calls (table cells), doc.y may be stale from
+                            // a previous cell — use the explicit firstY instead.
+                            const emojiY = (!usedExplicitCoords && firstY !== undefined) ? firstY : doc.y;
+                            doc.font(prevFont).fontSize(prevSize);
+                            if (!usedExplicitCoords && firstX !== undefined) {
+                                doc.text(placeholder, firstX, firstY, { ...opts, continued: eCont });
+                                usedExplicitCoords = true;
+                            }
+                            else {
+                                doc.text(placeholder, { ...opts, continued: eCont });
+                            }
+                            // Compute alignment-aware X position for the emoji image.
+                            let placedX = emojiX + (placeholderW - emojiSize) / 2;
+                            if (firstX !== undefined && typeof opts.width === 'number' && !doc._wrapper) {
+                                // Table cell with alignment — PDFKit already rendered the
+                                // placeholder at the aligned position; match it.
+                                const cellW = opts.width;
+                                const a = opts.align || 'left';
+                                if (a === 'center')
+                                    placedX = firstX + (cellW - emojiSize) / 2;
+                                else if (a === 'right')
+                                    placedX = firstX + cellW - emojiSize;
+                            }
+                            emojiPlacements.push({
+                                png,
+                                x: placedX,
+                                y: emojiY + yOffset,
+                            });
+                        }
+                        else {
+                            // Fallback: monochrome glyph.
+                            if (emojiEnabled)
+                                doc.font(EMOJI_FONT_NAME).fontSize(prevSize);
+                            if (!usedExplicitCoords && firstX !== undefined) {
+                                doc.text(em[0], firstX, firstY, { ...opts, continued: isLastEmoji ? !!opts.continued : true });
+                                usedExplicitCoords = true;
+                            }
+                            else {
+                                doc.text(em[0], { ...opts, continued: isLastEmoji ? !!opts.continued : true });
+                            }
+                            doc.font(prevFont).fontSize(prevSize);
+                        }
+                    }
+                }
+                else {
+                    // ── Text segment ──
+                    doc.font(prevFont).fontSize(prevSize);
+                    if (!usedExplicitCoords && firstX !== undefined) {
+                        doc.text(seg.text, firstX, firstY, { ...opts, continued: cont });
+                        usedExplicitCoords = true;
+                    }
+                    else {
+                        doc.text(seg.text, { ...opts, continued: cont });
+                    }
+                }
+            }
+            // ── Pass 2: overlay emoji images at recorded positions ──
+            const savedY = doc.y;
+            const savedX = doc.x;
+            for (const ep of emojiPlacements) {
+                doc.image(ep.png, ep.x, ep.y, {
+                    width: emojiSize,
+                    height: emojiSize,
+                });
+            }
+            doc.y = savedY;
+            doc.x = savedX;
+            doc.font(prevFont).fontSize(prevSize);
+            return;
+        }
+        // ── Monochrome font path (original behaviour) ────────────────────────
+        for (let i = 0; i < segments.length; i++) {
+            const seg = segments[i];
+            const isLast = i === segments.length - 1;
+            const cont = isLast ? !!opts.continued : true;
+            if (seg.isEmoji) {
+                doc.font(EMOJI_FONT_NAME).fontSize(prevSize);
+            }
+            else {
+                doc.font(prevFont).fontSize(prevSize);
+            }
+            // Only pass explicit x,y for the very first segment.
+            if (i === 0 && firstX !== undefined) {
+                doc.text(seg.text, firstX, firstY, { ...opts, continued: cont });
+            }
+            else {
+                doc.text(seg.text, { ...opts, continued: cont });
+            }
+        }
+        // Restore the original font so subsequent calls aren't surprised.
+        doc.font(prevFont).fontSize(prevSize);
+    }
+    function renderCodespan(text, continued) {
+        const cs = theme.code.inline;
+        const hPad = 2; // horizontal padding each side
+        const vPad = 1; // vertical padding each side
+        doc.font(cs.font).fontSize(cs.fontSize);
+        const textW = doc.widthOfString(text);
+        const textH = doc.currentLineHeight();
+        // Determine flow position.  If this is the first output in a table cell,
+        // use the cell context coordinates; otherwise read from the LineWrapper.
+        let flowX;
+        let flowY;
+        let useCellPos = false;
+        let cellExtra = {};
+        if (cellCtx && !cellCtx.used) {
+            flowX = cellCtx.x;
+            flowY = cellCtx.y;
+            useCellPos = true;
+            cellExtra = { width: cellCtx.width, align: cellCtx.align };
+            cellCtx.used = true;
+        }
+        else {
+            // Read the real flow X position from PDFKit's internal LineWrapper.
+            // After continued:true, doc.x stays at the left margin — the actual
+            // cursor position is _wrapper.startX + _wrapper.continuedX.
+            const w = doc._wrapper;
+            flowX = w ? (w.startX + w.continuedX) : doc.x;
+            flowY = doc.y;
+        }
+        // Draw background at the current flow position (behind the text)
+        doc.save();
+        doc.roundedRect(flowX - hPad, flowY, textW + hPad * 2, textH + vPad * 2, 2)
+            .fill(cs.backgroundColor);
+        doc.restore();
+        // Render inline — use positioned form for cell context, flow form otherwise
+        doc.font(cs.font).fontSize(cs.fontSize).fillColor(cs.color);
+        if (useCellPos) {
+            doc.text(text, flowX, flowY, { continued, ...cellExtra });
+        }
+        else {
+            doc.text(text, { continued });
+        }
+        resetBodyFont();
+    }
+    function renderLink(tok, continued) {
+        if (headingCtx) {
+            doc.font(headingCtx.font).fontSize(headingCtx.fontSize).fillColor(theme.linkColor);
+        }
+        else {
+            doc.font(theme.body.font).fontSize(theme.body.fontSize).fillColor(theme.linkColor);
+        }
+        const linkText = tok.text || tok.href;
+        renderTextWithEmoji(linkText, { continued, underline: true, link: tok.href });
+        doc.fillColor(headingCtx ? headingCtx.color : theme.body.color);
+    }
+    async function renderInlineTokens(inlineTokens, continued, insideBold = false, insideItalic = false) {
+        for (let i = 0; i < inlineTokens.length; i++) {
+            const isLast = i === inlineTokens.length - 1;
+            const cont = continued || !isLast;
+            const tok = inlineTokens[i];
+            switch (tok.type) {
+                case 'text': {
+                    const t = tok;
+                    if (t.tokens && t.tokens.length > 0) {
+                        await renderInlineTokens(t.tokens, cont, insideBold, insideItalic);
+                    }
+                    else {
+                        applyBodyFont(insideBold, insideItalic);
+                        renderTextWithEmoji(t.text, { continued: cont, underline: false, strike: false });
+                    }
+                    break;
+                }
+                case 'strong': {
+                    const t = tok;
+                    await renderInlineTokens(t.tokens, cont, true, insideItalic);
+                    break;
+                }
+                case 'em': {
+                    const t = tok;
+                    await renderInlineTokens(t.tokens, cont, insideBold, true);
+                    break;
+                }
+                case 'codespan': {
+                    renderCodespan(tok.text, cont);
+                    break;
+                }
+                case 'link': {
+                    renderLink(tok, cont);
+                    break;
+                }
+                case 'image': {
+                    await renderImage(tok);
+                    break;
+                }
+                case 'del': {
+                    applyBodyFont(insideBold, insideItalic);
+                    renderTextWithEmoji(tok.text, { continued: cont, strike: true, underline: false });
+                    break;
+                }
+                case 'escape': {
+                    applyBodyFont(insideBold, insideItalic);
+                    renderTextWithEmoji(tok.text, { continued: cont, underline: false, strike: false });
+                    break;
+                }
+                case 'br': {
+                    doc.moveDown(0.5);
+                    break;
+                }
+                default: {
+                    const raw = tok.text ?? tok.raw ?? '';
+                    if (raw) {
+                        applyBodyFont(insideBold, insideItalic);
+                        renderTextWithEmoji(raw, { continued: cont, underline: false, strike: false });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    async function renderImage(tok) {
+        try {
+            // Use the pluggable image renderer
+            const imgBuffer = await imageRenderer(tok.href);
+            // Read the image's intrinsic dimensions via pdfkit
+            // openImage exists at runtime but is missing from @types/pdfkit
+            const img = doc.openImage(imgBuffer);
+            const maxHeight = doc.page.height - margins.top - margins.bottom;
+            // Scale down to fit content area, but never scale up beyond natural size
+            let displayWidth = Math.min(img.width, contentWidth);
+            let displayHeight = img.height * (displayWidth / img.width);
+            // Also cap height to the printable area
+            if (displayHeight > maxHeight) {
+                displayHeight = maxHeight;
+                displayWidth = img.width * (displayHeight / img.height);
+            }
+            ensureSpace(displayHeight + 10);
+            doc.image(imgBuffer, { width: displayWidth, height: displayHeight });
+            doc.moveDown(0.5);
+        }
+        catch {
+            ensureSpace(20);
+            resetBodyFont();
+            doc.text(`[Image: ${tok.text || 'image'}]`);
+            doc.moveDown(0.3);
+        }
+    }
+    async function renderList(list, depth) {
+        const indent = margins.left + depth * 20;
+        for (let idx = 0; idx < list.items.length; idx++) {
+            const item = list.items[idx];
+            ensureSpace(theme.body.fontSize * 2);
+            resetBodyFont();
+            const bullet = list.ordered ? `${list.start + idx}.` : '•';
+            doc.text(bullet, indent, doc.y, { continued: true, width: contentWidth - depth * 20 });
+            doc.text(' ', { continued: true });
+            // Render item inline tokens
+            const itemTokens = item.tokens;
+            for (const child of itemTokens) {
+                if (child.type === 'text') {
+                    const t = child;
+                    if (t.tokens && t.tokens.length > 0) {
+                        await renderInlineTokens(t.tokens, false);
+                    }
+                    else {
+                        renderTextWithEmoji(t.text);
+                    }
+                }
+                else if (child.type === 'paragraph') {
+                    await renderInlineTokens(child.tokens, false);
+                }
+                else if (child.type === 'list') {
+                    await renderList(child, depth + 1);
+                }
+            }
+            doc.moveDown(0.2);
+        }
+    }
+    async function renderCellTokens(cell, x, y, width, align, bold) {
+        const savedY = doc.y;
+        if (cell.tokens && cell.tokens.length > 0) {
+            cellCtx = { x, y, width, align, used: false };
+            applyBodyFont(bold, false);
+            await renderInlineTokens(cell.tokens, false, bold, false);
+            cellCtx = null;
+        }
+        else {
+            // Fallback: plain text (no inline tokens)
+            applyBodyFont(bold, false);
+            renderTextWithEmoji(cell.text, x, y, { width, align });
+        }
+        doc.y = savedY;
+    }
+    async function renderTable(table) {
+        const colCount = table.header.length;
+        if (colCount === 0)
+            return;
+        const cellPad = theme.table.cellPadding;
+        const colWidth = contentWidth / colCount;
+        const rowH = theme.body.fontSize + cellPad * 2 + 4;
+        const textInsetY = (rowH - theme.body.fontSize) / 2;
+        ensureSpace(rowH * 2);
+        const startX = margins.left;
+        let y = doc.y;
+        // Header row
+        doc.save();
+        doc.rect(startX, y, contentWidth, rowH).fill(theme.table.headerBackground);
+        doc.restore();
+        for (let c = 0; c < colCount; c++) {
+            const cellX = startX + c * colWidth;
+            await renderCellTokens(table.header[c], cellX + cellPad, y + textInsetY, colWidth - cellPad * 2, table.align[c] || 'left', true);
+        }
+        // Header border
+        doc.save();
+        doc.strokeColor(theme.table.borderColor).lineWidth(0.5);
+        doc.rect(startX, y, contentWidth, rowH).stroke();
+        for (let c = 1; c < colCount; c++) {
+            const cx = startX + c * colWidth;
+            doc.moveTo(cx, y).lineTo(cx, y + rowH).stroke();
+        }
+        doc.restore();
+        y += rowH;
+        // Body rows
+        for (const row of table.rows) {
+            ensureSpace(rowH);
+            for (let c = 0; c < colCount; c++) {
+                const cellX = startX + c * colWidth;
+                await renderCellTokens(row[c], cellX + cellPad, y + textInsetY, colWidth - cellPad * 2, table.align[c] || 'left', false);
+            }
+            doc.save();
+            doc.strokeColor(theme.table.borderColor).lineWidth(0.5);
+            doc.rect(startX, y, contentWidth, rowH).stroke();
+            for (let c = 1; c < colCount; c++) {
+                const cx = startX + c * colWidth;
+                doc.moveTo(cx, y).lineTo(cx, y + rowH).stroke();
+            }
+            doc.restore();
+            y += rowH;
+        }
+        doc.x = margins.left;
+        doc.y = y;
+        doc.moveDown(0.5);
+        resetBodyFont();
+    }
+    async function renderToken(token) {
+        switch (token.type) {
+            case 'heading': {
+                const t = token;
+                const key = `h${t.depth}`;
+                const style = theme.headings[key];
+                const spaceAbove = style.fontSize * 0.8;
+                const spaceBelow = style.fontSize * 0.3;
+                ensureSpace(spaceAbove + style.fontSize + spaceBelow);
+                doc.moveDown(spaceAbove / doc.currentLineHeight());
+                doc.font(style.font).fontSize(style.fontSize).fillColor(style.color);
+                headingCtx = style;
+                if (t.tokens && t.tokens.length > 0) {
+                    await renderInlineTokens(t.tokens, false, style.bold ?? false, style.italic ?? false);
+                }
+                else {
+                    renderTextWithEmoji(t.text);
+                }
+                headingCtx = null;
+                doc.moveDown(spaceBelow / doc.currentLineHeight());
+                resetBodyFont();
+                break;
+            }
+            case 'paragraph': {
+                const t = token;
+                ensureSpace(theme.body.fontSize * 2);
+                resetBodyFont();
+                await renderInlineTokens(t.tokens, false);
+                doc.moveDown(0.5);
+                break;
+            }
+            case 'code': {
+                const t = token;
+                const cs = theme.code.block;
+                // Use syntax highlighting when a language is specified and highlighting is enabled
+                if (syntaxHighlight && t.lang) {
+                    const lines = t.text.split('\n');
+                    const lineH = cs.fontSize * 1.5;
+                    const blockH = lines.length * lineH + cs.padding * 2;
+                    ensureSpace(blockH + 10);
+                    const newY = (0, highlight_prism_js_1.renderCode)(doc, t.text, {
+                        language: t.lang,
+                        x: margins.left,
+                        y: doc.y,
+                        width: contentWidth,
+                        font: cs.font,
+                        fontSize: cs.fontSize,
+                        lineHeight: 1.5,
+                        padding: cs.padding,
+                        lineNumbers: true,
+                        drawBackground: true,
+                        theme: theme.syntaxHighlight,
+                    });
+                    doc.x = margins.left;
+                    doc.y = newY;
+                    doc.moveDown(0.5);
+                    resetBodyFont();
+                }
+                else {
+                    // Plain code block (no language or highlighting disabled)
+                    const lines = t.text.split('\n');
+                    const lineH = cs.fontSize * 1.4;
+                    const blockH = lines.length * lineH + cs.padding * 2;
+                    ensureSpace(blockH + 10);
+                    const x = margins.left;
+                    const y = doc.y;
+                    doc.save();
+                    doc.rect(x, y, contentWidth, blockH).fill(cs.backgroundColor);
+                    doc.restore();
+                    doc.font(cs.font).fontSize(cs.fontSize).fillColor(cs.color);
+                    let textY = y + cs.padding;
+                    for (const line of lines) {
+                        doc.text(line, x + cs.padding, textY, { width: contentWidth - cs.padding * 2 });
+                        textY += lineH;
+                    }
+                    doc.x = margins.left;
+                    doc.y = y + blockH;
+                    doc.moveDown(0.5);
+                    resetBodyFont();
+                }
+                break;
+            }
+            case 'blockquote': {
+                const t = token;
+                const bq = theme.blockquote;
+                ensureSpace(30);
+                const bqPadding = 6; // vertical padding above and below text
+                const startY = doc.y;
+                doc.y += bqPadding; // add top padding before text
+                const textX = margins.left + bq.borderWidth + bq.indent;
+                const textWidth = contentWidth - bq.borderWidth - bq.indent;
+                for (const child of t.tokens) {
+                    if (child.type === 'paragraph') {
+                        const p = child;
+                        const font = bq.italic ? 'Helvetica-Oblique' : theme.body.font;
+                        doc.font(font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+                        doc.text('', textX, doc.y, { width: textWidth });
+                        await renderInlineTokens(p.tokens, false, false, bq.italic);
+                        doc.moveDown(0.3);
+                    }
+                    else {
+                        await renderToken(child);
+                    }
+                }
+                doc.y += bqPadding; // add bottom padding after text
+                const endY = doc.y;
+                doc.save();
+                doc.rect(margins.left, startY, bq.borderWidth, endY - startY).fill(bq.borderColor);
+                doc.restore();
+                doc.x = margins.left;
+                doc.moveDown(0.3);
+                resetBodyFont();
+                break;
+            }
+            case 'list': {
+                await renderList(token, 0);
+                doc.moveDown(0.3);
+                break;
+            }
+            case 'hr': {
+                ensureSpace(20);
+                doc.moveDown(0.5);
+                const y = doc.y;
+                doc.save();
+                doc.strokeColor(theme.horizontalRuleColor).lineWidth(1)
+                    .moveTo(margins.left, y)
+                    .lineTo(margins.left + contentWidth, y)
+                    .stroke();
+                doc.restore();
+                doc.y = y;
+                doc.moveDown(0.5);
+                resetBodyFont();
+                break;
+            }
+            case 'table': {
+                await renderTable(token);
+                break;
+            }
+            case 'image': {
+                await renderImage(token);
+                break;
+            }
+            case 'space':
+            case 'html':
+                break;
+            default:
+                break;
+        }
+    }
+    // ── Main loop ─────────────────────────────────────────────────────────────
+    for (const token of tokens) {
+        await renderToken(token);
+    }
+    doc.end();
+    return new Promise((resolve) => {
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+}