@speajus/markdown-to-pdf 1.0.0

package/README.md

@@ -0,0 +1,167 @@
+# Basic-Markdown-To-PDF
+
+A lightweight TypeScript library that converts Markdown files into styled PDF documents. Built on [marked](https://github.com/markedjs/marked) for parsing and [PDFKit](https://pdfkit.org/) for PDF generation.
+
+## Features
+
+- **Headings** (h1–h6) with configurable fonts, sizes, and colors
+- **Inline formatting** — bold, italic, bold-italic, strikethrough, inline code
+- **Code blocks** with monospace font and background shading
+- **Blockquotes** with colored left border
+- **Lists** — ordered and unordered, with nested sub-lists
+- **Tables** with header row highlighting and cell borders
+- **Links** rendered as clickable PDF hyperlinks
+- **Images** — local (PNG, JPEG) and remote (HTTP/HTTPS) with automatic SVG-to-PNG conversion via [@resvg/resvg-js](https://github.com/nicolo-ribaudo/resvg-js)
+- **Horizontal rules**
+- **Automatic page breaks** when content exceeds the current page
+- **Fully themeable** — customize fonts, colors, spacing, page size, and margins
+
+## Installation
+
+```bash
+npm install
+```
+
+## Quick Start
+
+### CLI
+
+Convert a Markdown file to PDF from the command line:
+
+```bash
+npx ts-node src/cli.ts <input.md> [output.pdf]
+```
+
+If the output path is omitted, the PDF is written alongside the input file with a `.pdf` extension.
+
+```bash
+# Converts README.md → README.pdf
+npx ts-node src/cli.ts README.md
+
+# Explicit output path
+npx ts-node src/cli.ts docs/report.md output/report.pdf
+```
+
+### Programmatic API
+
+```typescript
+import { generatePdf } from './src/index';
+
+// File-based — reads Markdown from disk, writes PDF to disk
+await generatePdf('samples/sample.md', 'output/sample.pdf');
+
+// Buffer-based — returns a PDF Buffer for further processing
+import { renderMarkdownToPdf } from './src/index';
+
+const markdown = '# Hello World\n\nThis is a **test**.';
+const pdfBuffer = await renderMarkdownToPdf(markdown);
+```
+
+### Generate Sample PDFs
+
+The `samples/` directory contains example Markdown files. Generate PDFs for all of them at once:
+
+```bash
+npm run generate
+```
+
+Output is written to the `output/` directory.
+
+## Configuration
+
+Both `generatePdf` and `renderMarkdownToPdf` accept an optional `PdfOptions` object:
+
+```typescript
+interface PdfOptions {
+  theme?: ThemeConfig;     // Typography, colors, and component styles
+  pageLayout?: PageLayout; // Page size and margins
+  basePath?: string;       // Base directory for resolving relative image paths
+}
+```
+
+### Page Layout
+
+```typescript
+import { generatePdf } from './src/index';
+
+await generatePdf('input.md', 'output.pdf', {
+  pageLayout: {
+    pageSize: 'A4',
+    margins: { top: 72, right: 72, bottom: 72, left: 72 },
+  },
+});
+```
+
+The default layout uses **Letter** page size with 50pt margins on all sides.
+
+### Theming
+
+Override any part of the default theme to customize the look of the generated PDF:
+
+```typescript
+import { generatePdf, defaultTheme } from './src/index';
+
+await generatePdf('input.md', 'output.pdf', {
+  theme: {
+    ...defaultTheme,
+    headings: {
+      ...defaultTheme.headings,
+      h1: { font: 'Helvetica-Bold', fontSize: 32, color: '#0a3d62', bold: true },
+    },
+    linkColor: '#e74c3c',
+  },
+});
+```
+
+The full `ThemeConfig` interface exposes styles for:
+
+| Section        | Configurable properties                             |
+| -------------- | --------------------------------------------------- |
+| `headings`     | Font, size, and color for each level (h1–h6)        |
+| `body`         | Font, size, color, and line gap                     |
+| `code.inline`  | Font, size, color, and background color              |
+| `code.block`   | Font, size, color, background color, and padding     |
+| `blockquote`   | Border color, border width, italic flag, and indent  |
+| `table`        | Header background, border color, and cell padding    |
+| `linkColor`    | Color for hyperlink text                             |
+| `horizontalRuleColor` | Color for `---` dividers                      |
+
+## Project Structure
+
+```
+├── src/
+│   ├── index.ts      # Public API — generatePdf, renderMarkdownToPdf, exports
+│   ├── cli.ts        # Command-line entry point
+│   ├── renderer.ts   # Markdown-to-PDF rendering engine
+│   ├── styles.ts     # Default theme and page layout
+│   └── types.ts      # TypeScript interfaces for options and theming
+├── samples/
+│   ├── generate.ts   # Script to batch-generate sample PDFs
+│   ├── sample.md     # Full-featured sample document
+│   ├── image.md      # Image rendering tests (local, remote, SVG, broken)
+│   ├── logo.svg      # Sample SVG image
+│   ├── logo.png      # Sample PNG image
+│   └── sample.png    # Sample raster image
+├── output/           # Generated PDF output directory
+├── package.json
+└── tsconfig.json
+```
+
+## Dependencies
+
+| Package | Purpose |
+| ------- | ------- |
+| [marked](https://github.com/markedjs/marked) | Markdown parsing and tokenization |
+| [pdfkit](https://pdfkit.org/) | PDF document generation |
+| [@resvg/resvg-js](https://github.com/nicolo-ribaudo/resvg-js) | SVG-to-PNG rasterization for image embedding |
+
+## Scripts
+
+| Command | Description |
+| ------- | ----------- |
+| `npm run build` | Compile TypeScript to `dist/` |
+| `npm run generate` | Generate sample PDFs from `samples/*.md` into `output/` |
+
+## License
+
+ISC

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const index_js_1 = require("./index.js");
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.error('Usage: ts-node src/cli.ts <input.md> [output.pdf]');
+        process.exit(1);
+    }
+    const inputPath = args[0];
+    const outputPath = args[1] ?? inputPath.replace(/\.md$/i, '.pdf');
+    console.log(`Converting ${inputPath} → ${outputPath}`);
+    await (0, index_js_1.generatePdf)(inputPath, outputPath);
+    console.log(`Done. PDF written to ${path_1.default.resolve(outputPath)}`);
+}
+main().catch((err) => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export type { TextStyle, PageLayout, CodeStyle, CodeBlockStyle, BlockquoteStyle, TableStyles, ThemeConfig, PdfOptions, } from './types.js';
+export { renderMarkdownToPdf } from './renderer.js';
+export { defaultTheme, defaultPageLayout } from './styles.js';
+import type { PdfOptions } from './types.js';
+export declare function generatePdf(inputPath: string, outputPath: string, options?: PdfOptions): Promise<void>;

package/dist/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPageLayout = exports.defaultTheme = exports.renderMarkdownToPdf = void 0;
+exports.generatePdf = generatePdf;
+var renderer_js_1 = require("./renderer.js");
+Object.defineProperty(exports, "renderMarkdownToPdf", { enumerable: true, get: function () { return renderer_js_1.renderMarkdownToPdf; } });
+var styles_js_1 = require("./styles.js");
+Object.defineProperty(exports, "defaultTheme", { enumerable: true, get: function () { return styles_js_1.defaultTheme; } });
+Object.defineProperty(exports, "defaultPageLayout", { enumerable: true, get: function () { return styles_js_1.defaultPageLayout; } });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const renderer_js_2 = require("./renderer.js");
+async function generatePdf(inputPath, outputPath, options) {
+    const resolvedInput = path_1.default.resolve(inputPath);
+    const markdown = fs_1.default.readFileSync(resolvedInput, 'utf-8');
+    const basePath = path_1.default.dirname(resolvedInput);
+    const mergedOptions = { ...options, basePath: options?.basePath ?? basePath };
+    const buffer = await (0, renderer_js_2.renderMarkdownToPdf)(markdown, mergedOptions);
+    const dir = path_1.default.dirname(path_1.default.resolve(outputPath));
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.resolve(outputPath), buffer);
+}

package/dist/src/renderer.d.ts

@@ -0,0 +1,2 @@
+import type { PdfOptions } from './types.js';
+export declare function renderMarkdownToPdf(markdown: string, options?: PdfOptions): Promise<Buffer>;

package/dist/src/renderer.js

@@ -0,0 +1,423 @@
+"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 resvg_js_1 = require("@resvg/resvg-js");
+const stream_1 = require("stream");
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function isSvg(buf) {
+    // Check for XML/SVG signature in the first 256 bytes
+    const head = buf.subarray(0, 256).toString('utf-8').trimStart();
+    return head.startsWith('<svg') || head.startsWith('<?xml');
+}
+function convertSvgToPng(svgData) {
+    const resvg = new resvg_js_1.Resvg(svgData, { font: { loadSystemFonts: true } });
+    const rendered = resvg.render();
+    return Buffer.from(rendered.asPng());
+}
+const FETCH_TIMEOUT_MS = 10000;
+const MAX_REDIRECTS = 5;
+function fetchImageBuffer(url, redirectCount = 0) {
+    if (redirectCount > MAX_REDIRECTS) {
+        return Promise.reject(new Error(`Too many redirects fetching ${url}`));
+    }
+    return new Promise((resolve, reject) => {
+        const get = url.startsWith('https') ? https_1.default.get : http_1.default.get;
+        const req = get(url, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume(); // drain the response so the socket can be reused / freed
+                fetchImageBuffer(res.headers.location, redirectCount + 1).then(resolve, reject);
+                return;
+            }
+            if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+                res.resume();
+                reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+                return;
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(FETCH_TIMEOUT_MS, () => {
+            req.destroy(new Error(`Timeout fetching ${url} after ${FETCH_TIMEOUT_MS}ms`));
+        });
+    });
+}
+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 ?? process.cwd();
+    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));
+    const tokens = marked_1.marked.lexer(markdown);
+    const contentWidth = doc.page.width - margins.left - margins.right;
+    function ensureSpace(needed) {
+        if (doc.y + needed > doc.page.height - margins.bottom) {
+            doc.addPage();
+        }
+    }
+    function applyBodyFont(bold, italic) {
+        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() {
+        doc.font(theme.body.font).fontSize(theme.body.fontSize).fillColor(theme.body.color);
+    }
+    function renderCodespan(text, continued) {
+        const cs = theme.code.inline;
+        doc.font(cs.font).fontSize(cs.fontSize);
+        const textW = doc.widthOfString(text);
+        const textH = doc.currentLineHeight();
+        const bgX = doc.x;
+        const bgY = doc.y;
+        doc.save();
+        doc.rect(bgX, bgY, textW + 4, textH + 2).fill(cs.backgroundColor);
+        doc.restore();
+        doc.font(cs.font).fontSize(cs.fontSize).fillColor(cs.color);
+        doc.text(text, bgX + 2, bgY + 1, { continued });
+        resetBodyFont();
+    }
+    function renderLink(tok, continued) {
+        doc.font(theme.body.font).fontSize(theme.body.fontSize).fillColor(theme.linkColor);
+        const linkText = tok.text || tok.href;
+        doc.text(linkText, { continued, underline: true, link: tok.href });
+        doc.fillColor(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);
+                        doc.text(t.text, { continued: cont });
+                    }
+                    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);
+                    doc.text(tok.text, { continued: cont, strike: true });
+                    break;
+                }
+                case 'escape': {
+                    applyBodyFont(insideBold, insideItalic);
+                    doc.text(tok.text, { continued: cont });
+                    break;
+                }
+                case 'br': {
+                    doc.moveDown(0.5);
+                    break;
+                }
+                default: {
+                    const raw = tok.text ?? tok.raw ?? '';
+                    if (raw) {
+                        applyBodyFont(insideBold, insideItalic);
+                        doc.text(raw, { continued: cont });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    async function renderImage(tok) {
+        try {
+            let imgBuffer;
+            if (tok.href.startsWith('http://') || tok.href.startsWith('https://')) {
+                imgBuffer = await fetchImageBuffer(tok.href);
+            }
+            else {
+                // Local file path — resolve relative to the markdown file's directory
+                const imgPath = path_1.default.resolve(basePath, tok.href);
+                imgBuffer = fs_1.default.readFileSync(imgPath);
+            }
+            // Convert SVG to PNG since pdfkit doesn't support SVG natively
+            if (isSvg(imgBuffer)) {
+                imgBuffer = convertSvgToPng(imgBuffer);
+            }
+            // 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 {
+                        doc.text(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 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();
+        doc.font('Helvetica-Bold').fontSize(theme.body.fontSize).fillColor(theme.body.color);
+        for (let c = 0; c < colCount; c++) {
+            const cellX = startX + c * colWidth;
+            doc.text(table.header[c].text, cellX + cellPad, y + textInsetY, {
+                width: colWidth - cellPad * 2,
+                height: rowH,
+                align: table.align[c] || 'left',
+            });
+        }
+        // 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
+        resetBodyFont();
+        for (const row of table.rows) {
+            ensureSpace(rowH);
+            for (let c = 0; c < colCount; c++) {
+                const cellX = startX + c * colWidth;
+                doc.text(row[c].text, cellX + cellPad, y + textInsetY, {
+                    width: colWidth - cellPad * 2,
+                    height: rowH,
+                    align: table.align[c] || 'left',
+                });
+            }
+            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);
+                doc.text(t.text);
+                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;
+                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)));
+    });
+}

package/dist/src/styles.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeConfig, PageLayout } from './types.js';
+export declare const defaultTheme: ThemeConfig;
+export declare const defaultPageLayout: PageLayout;

package/dist/src/styles.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPageLayout = exports.defaultTheme = void 0;
+exports.defaultTheme = {
+    headings: {
+        h1: { font: 'Helvetica-Bold', fontSize: 28, color: '#1a1a1a', bold: true },
+        h2: { font: 'Helvetica-Bold', fontSize: 22, color: '#2a2a2a', bold: true },
+        h3: { font: 'Helvetica-Bold', fontSize: 18, color: '#3a3a3a', bold: true },
+        h4: { font: 'Helvetica-Bold', fontSize: 16, color: '#4a4a4a', bold: true },
+        h5: { font: 'Helvetica-Bold', fontSize: 14, color: '#5a5a5a', bold: true },
+        h6: { font: 'Helvetica-Bold', fontSize: 12, color: '#6a6a6a', bold: true },
+    },
+    body: {
+        font: 'Helvetica',
+        fontSize: 11,
+        color: '#333333',
+        lineGap: 4,
+    },
+    code: {
+        inline: {
+            font: 'Courier',
+            fontSize: 10,
+            color: '#c7254e',
+            backgroundColor: '#f9f2f4',
+        },
+        block: {
+            font: 'Courier',
+            fontSize: 9,
+            color: '#333333',
+            backgroundColor: '#f5f5f5',
+            padding: 8,
+        },
+    },
+    blockquote: {
+        borderColor: '#3498db',
+        borderWidth: 3,
+        italic: true,
+        indent: 20,
+    },
+    linkColor: '#2980b9',
+    horizontalRuleColor: '#cccccc',
+    table: {
+        headerBackground: '#f0f0f0',
+        borderColor: '#cccccc',
+        cellPadding: 6,
+    },
+};
+exports.defaultPageLayout = {
+    pageSize: 'LETTER',
+    margins: {
+        top: 50,
+        right: 50,
+        bottom: 50,
+        left: 50,
+    },
+};

package/dist/src/types.d.ts

@@ -0,0 +1,62 @@
+export interface TextStyle {
+    font: string;
+    fontSize: number;
+    color: string;
+    lineGap?: number;
+    bold?: boolean;
+    italic?: boolean;
+}
+export interface PageLayout {
+    pageSize: string;
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+export interface CodeStyle {
+    font: string;
+    fontSize: number;
+    color: string;
+    backgroundColor: string;
+}
+export interface CodeBlockStyle extends CodeStyle {
+    padding: number;
+}
+export interface BlockquoteStyle {
+    borderColor: string;
+    borderWidth: number;
+    italic: boolean;
+    indent: number;
+}
+export interface TableStyles {
+    headerBackground: string;
+    borderColor: string;
+    cellPadding: number;
+}
+export interface ThemeConfig {
+    headings: {
+        h1: TextStyle;
+        h2: TextStyle;
+        h3: TextStyle;
+        h4: TextStyle;
+        h5: TextStyle;
+        h6: TextStyle;
+    };
+    body: TextStyle;
+    code: {
+        inline: CodeStyle;
+        block: CodeBlockStyle;
+    };
+    blockquote: BlockquoteStyle;
+    linkColor: string;
+    horizontalRuleColor: string;
+    table: TableStyles;
+}
+export interface PdfOptions {
+    theme?: ThemeConfig;
+    pageLayout?: PageLayout;
+    /** Base directory for resolving relative image paths */
+    basePath?: string;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@speajus/markdown-to-pdf",
+  "version": "1.0.0",
+  "description": "A new project created with Intent by Augment.",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "generate": "ts-node samples/generate.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["markdown", "pdf", "converter"],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/speajus/markdown-to-pdf"
+  },
+  "type": "commonjs",
+  "dependencies": {
+    "@resvg/resvg-js": "^2.6.2",
+    "marked": "^17.0.2",
+    "pdfkit": "^0.17.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "@types/pdfkit": "^0.17.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}