@speajus/markdown-to-pdf 1.0.14 → 1.0.16

package/dist/renderer.js

@@ -10,10 +10,15 @@ 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';
+/** Name used to identify the emoji font (for safeFont checks). */
+const EMOJI_FONT_NAME = 'EmojiFont';
+/** Standard PDF fonts built into PDFKit — always available without filesystem access. */
+const STANDARD_PDF_FONTS = new Set([
+    'Helvetica', 'Helvetica-Bold', 'Helvetica-Oblique', 'Helvetica-BoldOblique',
+    'Courier', 'Courier-Bold', 'Courier-Oblique', 'Courier-BoldOblique',
+    'Times-Roman', 'Times-Bold', 'Times-Italic', 'Times-BoldItalic',
+    'Symbol', 'ZapfDingbats',
+]);
 async function renderMarkdownToPdf(markdown, options) {
     const theme = options?.theme ?? styles_js_1.defaultTheme;
     const layout = options?.pageLayout ?? styles_js_1.defaultPageLayout;
@@ -24,49 +29,61 @@ async function renderMarkdownToPdf(markdown, options) {
     }
     const lineNumbers = options?.lineNumbers ?? false;
     const zebraStripes = options?.zebraStripes !== false;
-    const emojiFontOpt = options?.emojiFont ?? true;
+    // ── Resolve effective emoji font setting ──────────────────────────────
+    // PdfOptions.emojiFont (boolean | string | Buffer) overrides theme when
+    // explicitly set; otherwise fall back to theme.emojiFont ('twemoji'|'openmoji'|'none').
+    const themeEmojiFont = theme.emojiFont ?? 'twemoji';
+    const emojiFontOpt = options?.emojiFont !== undefined
+        ? options.emojiFont
+        : themeEmojiFont === 'none'
+            ? false
+            : themeEmojiFont; // 'twemoji' | 'openmoji'
     // 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;
+    // ── Resolve emoji font for pdfkit native color emoji support ────────────
+    // The fork at jspears/pdfkit#support-color-emoji-google handles emoji
+    // segmentation and rendering (COLR/CPAL, SBIX, CBDT) internally when
+    // an `emojiFont` option is passed to the PDFDocument constructor.
+    let resolvedEmojiFont;
     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;
+                resolvedEmojiFont = emojiFontOpt;
             }
             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');
+                let fontPath;
+                if (typeof emojiFontOpt === 'string' && emojiFontOpt !== 'twemoji' && emojiFontOpt !== 'openmoji' && emojiFontOpt !== 'none') {
+                    fontPath = emojiFontOpt; // custom file path
+                }
+                else if (emojiFontOpt === 'openmoji') {
+                    fontPath = nodePath.join(__dirname, 'fonts', 'OpenMoji-Color.ttf');
+                }
+                else {
+                    fontPath = nodePath.join(__dirname, 'fonts', 'Twemoji.Mozilla.ttf');
+                }
                 if (nodeFs.existsSync(fontPath)) {
-                    doc.registerFont(EMOJI_FONT_NAME, fontPath);
-                    emojiEnabled = true;
+                    resolvedEmojiFont = fontPath;
                 }
             }
         }
         catch {
-            // Font registration failed or Node.js APIs not available (browser) —
-            // fall through without emoji support.
+            // Node.js APIs not available (browser) — no emoji font.
         }
     }
+    const doc = new pdfkit_1.default({
+        size: layout.pageSize,
+        margins,
+        ...(resolvedEmojiFont ? { emojiFont: resolvedEmojiFont } : {}),
+    });
+    const stream = new stream_1.PassThrough();
+    const chunks = [];
+    doc.pipe(stream);
+    stream.on('data', (chunk) => chunks.push(chunk));
     // ── Custom font registration ─────────────────────────────────────────────
     // Register user-supplied font families so they can be referenced by name
     // in ThemeConfig font fields.  Each variant is registered with a suffix:
@@ -87,15 +104,22 @@ async function renderMarkdownToPdf(markdown, options) {
             }
         }
     }
-    // ── 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)());
+    // ── Browser font safety ────────────────────────────────────────────────
+    // In browser environments, `fs.readFileSync` doesn't exist.  When PDFKit
+    // encounters an unknown font name it tries to load it from disk via
+    // readFileSync, which crashes in the browser.  Detect whether we're in a
+    // filesystem-capable environment so we can guard calls to `doc.font()`.
+    let fsAvailable = false;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const nodeFs = require('fs');
+        fsAvailable = typeof nodeFs.readFileSync === 'function';
+    }
+    catch {
+        // Node.js `fs` not available — we're in a browser environment.
     }
+    // ── Spacing config ────────────────────────────────────────────────────
+    const sp = { ...styles_js_1.defaultSpacing, ...theme.spacing };
     const tokens = marked_1.marked.lexer(markdown);
     const contentWidth = doc.page.width - margins.left - margins.right;
     // ── Table cell context ──────────────────────────────────────────────────
@@ -122,6 +146,38 @@ async function renderMarkdownToPdf(markdown, options) {
             return customFontNames.has(font.substring(0, dash));
         return false;
     }
+    /**
+     * Return a safe font name that will not crash `doc.font()`.
+     *
+     * In Node.js (`fsAvailable === true`) this is a no-op — PDFKit can load
+     * fonts from the filesystem.  In browser environments, if the font is
+     * neither a standard PDF font nor a registered custom / emoji font, we
+     * return a standard fallback and log a warning so the user knows which
+     * font was unavailable.
+     */
+    function safeFont(name) {
+        if (fsAvailable)
+            return name;
+        if (STANDARD_PDF_FONTS.has(name) || isCustomFont(name) || name === EMOJI_FONT_NAME)
+            return name;
+        // Determine the closest standard fallback, preserving bold/italic intent
+        // by inspecting the variant suffix added by resolveFont().
+        let fallback;
+        if (name.endsWith('-BoldOblique') || name.endsWith('-BoldItalic')) {
+            fallback = 'Helvetica-BoldOblique';
+        }
+        else if (name.endsWith('-Bold')) {
+            fallback = 'Helvetica-Bold';
+        }
+        else if (name.endsWith('-Oblique') || name.endsWith('-Italic')) {
+            fallback = 'Helvetica-Oblique';
+        }
+        else {
+            fallback = 'Helvetica';
+        }
+        console.warn(`[markdown-to-pdf] Font "${name}" is not available; falling back to "${fallback}"`);
+        return fallback;
+    }
     /** Return the base (registered) name of a custom font, stripping any variant suffix. */
     function customFontBase(font) {
         if (customFontNames.has(font))
@@ -190,34 +246,30 @@ async function renderMarkdownToPdf(markdown, options) {
             let font = headingCtx.font;
             if (bold || italic)
                 font = resolveFont(font, bold, italic);
-            doc.font(font).fontSize(headingCtx.fontSize).fillColor(headingCtx.color);
+            doc.font(safeFont(font)).fontSize(headingCtx.fontSize).fillColor(headingCtx.color);
             return;
         }
         const font = resolveFont(theme.body.font, bold, italic);
-        doc.font(font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+        doc.font(safeFont(font)).fontSize(theme.body.fontSize).fillColor(theme.body.color);
     }
     function resetBodyFont() {
         if (headingCtx) {
-            doc.font(headingCtx.font).fontSize(headingCtx.fontSize).fillColor(headingCtx.color);
+            doc.font(safeFont(headingCtx.font)).fontSize(headingCtx.fontSize).fillColor(headingCtx.color);
             return;
         }
-        doc.font(theme.body.font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+        doc.font(safeFont(theme.body.font)).fontSize(theme.body.fontSize).fillColor(theme.body.color);
     }
     /**
-     * Render a text string switching to the emoji font for emoji characters.
+     * Render text, delegating to `doc.text()`.
      *
-     * 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.
+     * pdfkit's native color emoji support (via the `emojiFont` constructor
+     * option) handles emoji segmentation and rendering internally, so this
+     * function only normalises call signatures and handles table cell context.
      *
-     * 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.
+     * Supports both `renderText(text, opts?)` and the positioned form
+     * `renderText(text, x, y, opts?)` used by table cells.
      */
-    function renderTextWithEmoji(text, xOrOpts, yOrUndefined, posOpts) {
+    function renderText(text, xOrOpts, yOrUndefined, posOpts) {
         // Normalise the two call signatures into a single (opts, firstX, firstY).
         let opts;
         let firstX;
@@ -237,169 +289,18 @@ async function renderMarkdownToPdf(markdown, options) {
             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;
+        if (firstX !== undefined) {
+            doc.text(text, firstX, firstY, opts);
         }
-        // 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 });
-            }
+        else {
+            doc.text(text, opts);
         }
-        // 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);
+        doc.font(safeFont(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,
@@ -429,7 +330,7 @@ async function renderMarkdownToPdf(markdown, options) {
             .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);
+        doc.font(safeFont(cs.font)).fontSize(cs.fontSize).fillColor(cs.color);
         if (useCellPos) {
             doc.text(text, flowX, flowY, { continued, ...cellExtra });
         }
@@ -445,13 +346,13 @@ async function renderMarkdownToPdf(markdown, options) {
             return renderImage(imgChild, tok.href);
         }
         if (headingCtx) {
-            doc.font(headingCtx.font).fontSize(headingCtx.fontSize).fillColor(theme.linkColor);
+            doc.font(safeFont(headingCtx.font)).fontSize(headingCtx.fontSize).fillColor(theme.linkColor);
         }
         else {
-            doc.font(theme.body.font).fontSize(theme.body.fontSize).fillColor(theme.linkColor);
+            doc.font(safeFont(theme.body.font)).fontSize(theme.body.fontSize).fillColor(theme.linkColor);
         }
         const linkText = tok.text || tok.href;
-        renderTextWithEmoji(linkText, { continued, underline: true, link: tok.href });
+        renderText(linkText, { continued, underline: true, link: tok.href });
         doc.fillColor(headingCtx ? headingCtx.color : theme.body.color);
     }
     async function renderInlineTokens(inlineTokens, continued, insideBold = false, insideItalic = false) {
@@ -467,7 +368,7 @@ async function renderMarkdownToPdf(markdown, options) {
                     }
                     else {
                         applyBodyFont(insideBold, insideItalic);
-                        renderTextWithEmoji(t.text, { continued: cont, underline: false, strike: false });
+                        renderText(t.text, { continued: cont, underline: false, strike: false });
                     }
                     break;
                 }
@@ -495,12 +396,12 @@ async function renderMarkdownToPdf(markdown, options) {
                 }
                 case 'del': {
                     applyBodyFont(insideBold, insideItalic);
-                    renderTextWithEmoji(tok.text, { continued: cont, strike: true, underline: false });
+                    renderText(tok.text, { continued: cont, strike: true, underline: false });
                     break;
                 }
                 case 'escape': {
                     applyBodyFont(insideBold, insideItalic);
-                    renderTextWithEmoji(tok.text, { continued: cont, underline: false, strike: false });
+                    renderText(tok.text, { continued: cont, underline: false, strike: false });
                     break;
                 }
                 case 'br': {
@@ -511,7 +412,7 @@ async function renderMarkdownToPdf(markdown, options) {
                     const raw = tok.text ?? tok.raw ?? '';
                     if (raw) {
                         applyBodyFont(insideBold, insideItalic);
-                        renderTextWithEmoji(raw, { continued: cont, underline: false, strike: false });
+                        renderText(raw, { continued: cont, underline: false, strike: false });
                     }
                     break;
                 }
@@ -535,9 +436,12 @@ async function renderMarkdownToPdf(markdown, options) {
                 displayWidth = img.width * (displayHeight / img.height);
             }
             ensureSpace(displayHeight + 10);
-            const imgX = doc.x;
+            // Compute horizontal position based on imageAlign
+            const imgX = theme.imageAlign === 'center'
+                ? margins.left + (contentWidth - displayWidth) / 2
+                : doc.x;
             const imgY = doc.y;
-            doc.image(imgBuffer, { width: displayWidth, height: displayHeight });
+            doc.image(imgBuffer, imgX, imgY, { width: displayWidth, height: displayHeight });
             // If the image is wrapped in a link, overlay a clickable annotation
             if (linkUrl) {
                 doc.link(imgX, imgY, displayWidth, displayHeight, linkUrl);
@@ -552,13 +456,13 @@ async function renderMarkdownToPdf(markdown, options) {
         }
     }
     async function renderList(list, depth) {
-        const indent = margins.left + depth * 20;
+        const indent = margins.left + depth * sp.listIndent;
         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(bullet, indent, doc.y, { continued: true, width: contentWidth - depth * sp.listIndent });
             doc.text(' ', { continued: true });
             // Render item inline tokens
             const itemTokens = item.tokens;
@@ -569,7 +473,7 @@ async function renderMarkdownToPdf(markdown, options) {
                         await renderInlineTokens(t.tokens, false);
                     }
                     else {
-                        renderTextWithEmoji(t.text);
+                        renderText(t.text);
                     }
                 }
                 else if (child.type === 'paragraph') {
@@ -579,7 +483,7 @@ async function renderMarkdownToPdf(markdown, options) {
                     await renderList(child, depth + 1);
                 }
             }
-            doc.moveDown(0.2);
+            doc.moveDown(sp.listItemSpacing);
         }
     }
     async function renderCellTokens(cell, x, y, width, align, bold) {
@@ -593,7 +497,7 @@ async function renderMarkdownToPdf(markdown, options) {
         else {
             // Fallback: plain text (no inline tokens)
             applyBodyFont(bold, false);
-            renderTextWithEmoji(cell.text, x, y, { width, align });
+            renderText(cell.text, x, y, { width, align });
         }
         doc.y = savedY;
     }
@@ -662,17 +566,17 @@ async function renderMarkdownToPdf(markdown, options) {
                 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;
+                const spaceAbove = style.fontSize * sp.headingSpaceAbove;
+                const spaceBelow = style.fontSize * sp.headingSpaceBelow;
                 ensureSpace(spaceAbove + style.fontSize + spaceBelow);
                 doc.moveDown(spaceAbove / doc.currentLineHeight());
-                doc.font(style.font).fontSize(style.fontSize).fillColor(style.color);
+                doc.font(safeFont(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);
+                    renderText(t.text);
                 }
                 headingCtx = null;
                 // Draw an underline beneath h1 and h2
@@ -695,7 +599,7 @@ async function renderMarkdownToPdf(markdown, options) {
                 ensureSpace(theme.body.fontSize * 2);
                 resetBodyFont();
                 await renderInlineTokens(t.tokens, false);
-                doc.moveDown(0.5);
+                doc.moveDown(sp.paragraphSpacing);
                 break;
             }
             case 'code': {
@@ -712,17 +616,18 @@ async function renderMarkdownToPdf(markdown, options) {
                         x: margins.left,
                         y: doc.y,
                         width: contentWidth,
-                        font: cs.font,
+                        font: safeFont(cs.font),
                         fontSize: cs.fontSize,
                         lineHeight: 1.5,
                         padding: cs.padding,
                         lineNumbers,
                         drawBackground: true,
                         theme: theme.syntaxHighlight,
+                        borderRadius: cs.borderRadius,
                     });
                     doc.x = margins.left;
                     doc.y = newY;
-                    doc.moveDown(0.5);
+                    doc.moveDown(sp.codeBlockSpacing);
                     resetBodyFont();
                 }
                 else {
@@ -733,10 +638,16 @@ async function renderMarkdownToPdf(markdown, options) {
                     ensureSpace(blockH + 10);
                     const x = margins.left;
                     const y = doc.y;
+                    const cbRadius = cs.borderRadius ?? 0;
                     doc.save();
-                    doc.rect(x, y, contentWidth, blockH).fill(cs.backgroundColor);
+                    if (cbRadius > 0) {
+                        doc.roundedRect(x, y, contentWidth, blockH, cbRadius).fill(cs.backgroundColor);
+                    }
+                    else {
+                        doc.rect(x, y, contentWidth, blockH).fill(cs.backgroundColor);
+                    }
                     doc.restore();
-                    doc.font(cs.font).fontSize(cs.fontSize).fillColor(cs.color);
+                    doc.font(safeFont(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 });
@@ -744,7 +655,7 @@ async function renderMarkdownToPdf(markdown, options) {
                     }
                     doc.x = margins.left;
                     doc.y = y + blockH;
-                    doc.moveDown(0.5);
+                    doc.moveDown(sp.codeBlockSpacing);
                     resetBodyFont();
                 }
                 break;
@@ -753,7 +664,7 @@ async function renderMarkdownToPdf(markdown, options) {
                 const t = token;
                 const bq = theme.blockquote;
                 ensureSpace(30);
-                const bqPadding = 6; // vertical padding above and below text
+                const bqPadding = bq.padding ?? 6;
                 const startY = doc.y;
                 doc.y += bqPadding; // add top padding before text
                 const textX = margins.left + bq.borderWidth + bq.indent;
@@ -762,10 +673,10 @@ async function renderMarkdownToPdf(markdown, options) {
                     if (child.type === 'paragraph') {
                         const p = child;
                         const font = bq.italic ? italicVariant(theme.body.font) : theme.body.font;
-                        doc.font(font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+                        doc.font(safeFont(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);
+                        doc.moveDown(sp.blockquoteSpacing);
                     }
                     else {
                         await renderToken(child);
@@ -773,11 +684,18 @@ async function renderMarkdownToPdf(markdown, options) {
                 }
                 doc.y += bqPadding; // add bottom padding after text
                 const endY = doc.y;
+                // Draw optional background fill behind blockquote area
+                if (bq.backgroundColor) {
+                    doc.save();
+                    doc.rect(margins.left + bq.borderWidth, startY, contentWidth - bq.borderWidth, endY - startY).fill(bq.backgroundColor);
+                    doc.restore();
+                }
+                // Draw left border
                 doc.save();
                 doc.rect(margins.left, startY, bq.borderWidth, endY - startY).fill(bq.borderColor);
                 doc.restore();
                 doc.x = margins.left;
-                doc.moveDown(0.3);
+                doc.moveDown(sp.blockquoteSpacing);
                 resetBodyFont();
                 break;
             }
@@ -788,7 +706,7 @@ async function renderMarkdownToPdf(markdown, options) {
             }
             case 'hr': {
                 ensureSpace(20);
-                doc.moveDown(0.5);
+                doc.moveDown(sp.hrSpacing);
                 const y = doc.y;
                 doc.save();
                 doc.strokeColor(theme.horizontalRuleColor).lineWidth(1)
@@ -797,7 +715,7 @@ async function renderMarkdownToPdf(markdown, options) {
                     .stroke();
                 doc.restore();
                 doc.y = y;
-                doc.moveDown(0.5);
+                doc.moveDown(sp.hrSpacing);
                 resetBodyFont();
                 break;
             }

package/dist/styles.d.ts

@@ -1,4 +1,6 @@
-import type { ThemeConfig, PageLayout, SyntaxHighlightTheme } from './types.js';
+import type { ThemeConfig, PageLayout, SpacingConfig, SyntaxHighlightTheme } from './types.js';
+/** Default spacing values — used as fallbacks when theme.spacing is partial or absent. */
+export declare const defaultSpacing: Required<SpacingConfig>;
 /** Prism.js default light theme — used as the default (print-friendly). */
 export declare const defaultSyntaxHighlightTheme: SyntaxHighlightTheme;
 export declare const defaultTheme: ThemeConfig;