@speajus/markdown-to-pdf 1.0.3 → 1.0.5

package/dist/emoji.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Emoji detection and text segmentation utilities.
+ *
+ * Splits a string into runs of "emoji" vs "non-emoji" characters so the
+ * renderer can switch to an emoji font (e.g. Noto Emoji) for glyph coverage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmoji = isEmoji;
+exports.splitEmojiSegments = splitEmojiSegments;
+exports.containsEmoji = containsEmoji;
+exports.getEmojiRegex = getEmojiRegex;
+/**
+ * Regex that matches a single emoji "unit".
+ *
+ * Covers:
+ *  - Emoji presentation sequences  (base + U+FE0F)
+ *  - Keycap sequences              (digit + U+FE0F + U+20E3)
+ *  - Flag sequences                (regional indicators)
+ *  - ZWJ sequences                 (family, profession, etc.)
+ *  - Tag sequences                 (e.g. England flag)
+ *  - Modifier sequences            (skin-tone)
+ *  - Standalone emoji codepoints   in Emoticons, Dingbats, Symbols, etc.
+ *
+ * We use a wide net via Unicode property escapes where the runtime supports
+ * them, falling back to explicit ranges for broad compatibility.
+ */
+const EMOJI_RE = buildEmojiRegex();
+function buildEmojiRegex() {
+    // Modern runtimes (Node 10+) support Unicode property escapes.
+    // We try that first because it is maintained by the Unicode consortium
+    // and stays current with new emoji releases.
+    try {
+        // \p{Emoji_Presentation} — characters rendered as emoji by default
+        // \p{Emoji_Modifier_Base} — characters that accept skin-tone modifiers
+        // The rest handles ZWJ, keycap, flag, and tag sequences.
+        return new RegExp(
+        // Regional indicator flag pairs — MUST come first so that
+        // individual RI symbols are not consumed by the ZWJ / standalone
+        // branches before they can pair up.
+        '(?:[\\u{1F1E6}-\\u{1F1FF}]){2}' +
+            '|' +
+            // Tag sequences (e.g. flag of England)
+            '\\u{1F3F4}[\\u{E0060}-\\u{E007E}]+\\u{E007F}' +
+            '|' +
+            // Keycap sequences: digit/# /* + VS16 + combining enclosing keycap
+            '[0-9#*]\\uFE0F?\\u20E3' +
+            '|' +
+            // ZWJ sequences (family, professions, etc.)
+            '(?:' +
+            '(?:\\p{Emoji_Presentation}|\\p{Emoji_Modifier_Base})' +
+            '(?:\\p{Emoji_Modifier})?' +
+            '(?:\\u200D(?:\\p{Emoji_Presentation}|\\p{Emoji_Modifier_Base})(?:\\p{Emoji_Modifier})?)*)' +
+            '|' +
+            // Standalone emoji with optional VS16 — exclude RI range
+            // (U+1F1E6–U+1F1FF) so lone indicators don't match here.
+            '[\\u{1F000}-\\u{1F1E5}\\u{1F200}-\\u{1FAFF}\\u{2600}-\\u{27BF}\\u{2300}-\\u{23FF}\\u{2B50}\\u{2B55}\\u{FE00}-\\u{FE0F}\\u{200D}]\\uFE0F?' +
+            '', 'gu');
+    }
+    catch {
+        // Fallback: cover the most common emoji ranges without property escapes.
+        return new RegExp('[' +
+            '\\u{1F600}-\\u{1F64F}' + // Emoticons
+            '\\u{1F300}-\\u{1F5FF}' + // Misc Symbols & Pictographs
+            '\\u{1F680}-\\u{1F6FF}' + // Transport & Map
+            '\\u{1F900}-\\u{1F9FF}' + // Supplemental Symbols
+            '\\u{1FA00}-\\u{1FA6F}' + // Chess Symbols
+            '\\u{1FA70}-\\u{1FAFF}' + // Symbols Extended-A
+            '\\u{2600}-\\u{26FF}' + // Misc Symbols
+            '\\u{2700}-\\u{27BF}' + // Dingbats
+            '\\u{FE00}-\\u{FE0F}' + // Variation Selectors
+            '\\u{200D}' + // ZWJ
+            '\\u{1F1E6}-\\u{1F1FF}' + // Regional Indicators
+            ']+', 'gu');
+    }
+}
+/**
+ * Returns `true` when the whole string is emoji (one or more).
+ */
+function isEmoji(text) {
+    const stripped = text.replace(EMOJI_RE, '');
+    return stripped.trim().length === 0 && text.length > 0;
+}
+/**
+ * Split `text` into contiguous runs of emoji and non-emoji characters.
+ *
+ * Example:
+ *   splitEmojiSegments("Hello 🎉🔥 world")
+ *   => [
+ *        { text: "Hello ", isEmoji: false },
+ *        { text: "🎉🔥", isEmoji: true },
+ *        { text: " world", isEmoji: false },
+ *      ]
+ */
+function splitEmojiSegments(text) {
+    if (!text)
+        return [];
+    const segments = [];
+    let lastIndex = 0;
+    // Reset global regex state
+    EMOJI_RE.lastIndex = 0;
+    let match;
+    while ((match = EMOJI_RE.exec(text)) !== null) {
+        // Push any non-emoji text before this match
+        if (match.index > lastIndex) {
+            segments.push({ text: text.slice(lastIndex, match.index), isEmoji: false });
+        }
+        // Merge consecutive emoji matches into one segment
+        const prev = segments[segments.length - 1];
+        if (prev && prev.isEmoji) {
+            prev.text += match[0];
+        }
+        else {
+            segments.push({ text: match[0], isEmoji: true });
+        }
+        lastIndex = EMOJI_RE.lastIndex;
+    }
+    // Trailing non-emoji text
+    if (lastIndex < text.length) {
+        segments.push({ text: text.slice(lastIndex), isEmoji: false });
+    }
+    return segments;
+}
+/**
+ * Quick check: does the string contain at least one emoji?
+ */
+function containsEmoji(text) {
+    EMOJI_RE.lastIndex = 0;
+    return EMOJI_RE.test(text);
+}
+/**
+ * Returns the module-level emoji regex.  Useful for external callers
+ * (e.g. `preRenderEmoji`) that need to scan text with the same pattern.
+ */
+function getEmojiRegex() {
+    return EMOJI_RE;
+}

package/dist/highlight.prism.d.ts

@@ -0,0 +1,76 @@
+/**
+ * pdfkit-highlight.ts
+ * Syntax highlighting for PDFKit using Prism.js
+ *
+ * Usage:
+ *   import { loadHighlightLanguages, renderCode } from './highlight.prism.js';
+ *   loadHighlightLanguages(['javascript', 'python']); // or omit to load all
+ *   renderCode(doc, sourceCode, { language: 'javascript', x: 50, y: 100 });
+ */
+import 'prismjs/components/prism-typescript.js';
+import 'prismjs/components/prism-python.js';
+import 'prismjs/components/prism-bash.js';
+import 'prismjs/components/prism-json.js';
+import 'prismjs/components/prism-jsx.js';
+import 'prismjs/components/prism-tsx.js';
+import 'prismjs/components/prism-yaml.js';
+import 'prismjs/components/prism-sql.js';
+import 'prismjs/components/prism-go.js';
+import 'prismjs/components/prism-rust.js';
+import 'prismjs/components/prism-java.js';
+import 'prismjs/components/prism-c.js';
+import 'prismjs/components/prism-cpp.js';
+import 'prismjs/components/prism-diff.js';
+import 'prismjs/components/prism-markdown.js';
+import 'prismjs/components/prism-docker.js';
+import type PDFDocument from 'pdfkit';
+import type { SyntaxHighlightTheme } from './types.js';
+/**
+ * Load Prism.js language grammars for syntax highlighting.
+ *
+ * @param languages  Optional array of language identifiers to load
+ *                   (e.g. `['javascript', 'python', 'bash']`).
+ *                   When omitted or `undefined`, **all** available Prism.js
+ *                   languages (~300) are loaded.
+ *
+ * In Node.js, this dynamically loads grammars via `prismjs/components/`.
+ * In browser environments (Vite, webpack, etc.) the dynamic loader is not
+ * available; a set of common languages is pre-loaded via static imports
+ * and unknown languages degrade to unstyled plain text.
+ *
+ * Safe to call multiple times — subsequent calls are no-ops.
+ */
+export declare function loadHighlightLanguages(languages?: string[]): void;
+interface FlatToken {
+    type: string | null;
+    content: string;
+}
+export interface RenderCodeOptions {
+    language?: string;
+    x: number;
+    y: number;
+    width?: number;
+    font?: string;
+    fontSize?: number;
+    lineHeight?: number;
+    padding?: number;
+    lineNumbers?: boolean;
+    drawBackground?: boolean;
+    theme?: Partial<SyntaxHighlightTheme>;
+}
+export declare function colorFor(tokenType: string | null, theme: SyntaxHighlightTheme): string;
+/**
+ * Split flat tokens at newline boundaries so we get per-line arrays.
+ * Each line is an array of { type, content } segments (no newlines).
+ */
+export declare function tokenizeToLines(code: string, language: string): FlatToken[][];
+/**
+ * Render syntax-highlighted code into a PDFKit document.
+ *
+ * @param doc       PDFKit document instance
+ * @param code      Source code string
+ * @param opts      Rendering options
+ * @returns The Y position immediately after the rendered block
+ */
+export declare function renderCode(doc: InstanceType<typeof PDFDocument>, code: string, opts: RenderCodeOptions): number;
+export {};

package/dist/highlight.prism.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * pdfkit-highlight.ts
+ * Syntax highlighting for PDFKit using Prism.js
+ *
+ * Usage:
+ *   import { loadHighlightLanguages, renderCode } from './highlight.prism.js';
+ *   loadHighlightLanguages(['javascript', 'python']); // or omit to load all
+ *   renderCode(doc, sourceCode, { language: 'javascript', x: 50, y: 100 });
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHighlightLanguages = loadHighlightLanguages;
+exports.colorFor = colorFor;
+exports.tokenizeToLines = tokenizeToLines;
+exports.renderCode = renderCode;
+const prismjs_1 = __importDefault(require("prismjs"));
+// Static imports for commonly-used languages — these are self-registering
+// side-effect imports that work in both Node.js and browser environments.
+// Base Prism already includes: markup, css, clike, javascript.
+require("prismjs/components/prism-typescript.js");
+require("prismjs/components/prism-python.js");
+require("prismjs/components/prism-bash.js");
+require("prismjs/components/prism-json.js");
+require("prismjs/components/prism-jsx.js");
+require("prismjs/components/prism-tsx.js");
+require("prismjs/components/prism-yaml.js");
+require("prismjs/components/prism-sql.js");
+require("prismjs/components/prism-go.js");
+require("prismjs/components/prism-rust.js");
+require("prismjs/components/prism-java.js");
+require("prismjs/components/prism-c.js");
+require("prismjs/components/prism-cpp.js");
+require("prismjs/components/prism-diff.js");
+require("prismjs/components/prism-markdown.js");
+require("prismjs/components/prism-docker.js");
+const styles_js_1 = require("./styles.js");
+// ---------------------------------------------------------------------------
+// Language loading
+// ---------------------------------------------------------------------------
+let languagesLoaded = false;
+/**
+ * Load Prism.js language grammars for syntax highlighting.
+ *
+ * @param languages  Optional array of language identifiers to load
+ *                   (e.g. `['javascript', 'python', 'bash']`).
+ *                   When omitted or `undefined`, **all** available Prism.js
+ *                   languages (~300) are loaded.
+ *
+ * In Node.js, this dynamically loads grammars via `prismjs/components/`.
+ * In browser environments (Vite, webpack, etc.) the dynamic loader is not
+ * available; a set of common languages is pre-loaded via static imports
+ * and unknown languages degrade to unstyled plain text.
+ *
+ * Safe to call multiple times — subsequent calls are no-ops.
+ */
+function loadHighlightLanguages(languages) {
+    if (languagesLoaded)
+        return;
+    try {
+        // prismjs/components/index.js uses require.resolve() internally,
+        // which is only available in Node.js.  In browser bundlers (Vite,
+        // webpack) it is transformed to __require.resolve which does not exist.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const loadLanguages = require('prismjs/components/index.js');
+        loadLanguages.silent = true;
+        if (languages && languages.length > 0) {
+            loadLanguages(languages);
+        }
+        else {
+            loadLanguages(); // loads every language
+        }
+    }
+    catch {
+        // Browser / ESM environment — require.resolve not available.
+        // The static imports above cover the most common languages;
+        // any unsupported language falls back to unstyled plain text
+        // in tokenizeToLines().
+    }
+    languagesLoaded = true;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function colorFor(tokenType, theme) {
+    if (!tokenType)
+        return theme.tokens.default;
+    const types = tokenType.split(' ');
+    for (const t of types) {
+        if (theme.tokens[t])
+            return theme.tokens[t];
+    }
+    return theme.tokens.default;
+}
+/**
+ * Flatten Prism's nested token tree into a simple
+ * [{ type: string|null, content: string }] array.
+ */
+function flattenTokens(tokens) {
+    const result = [];
+    for (const token of tokens) {
+        if (typeof token === 'string') {
+            result.push({ type: null, content: token });
+        }
+        else if (token.type) {
+            const inner = flattenTokens(Array.isArray(token.content)
+                ? token.content
+                : [token.content]);
+            for (const child of inner) {
+                result.push({ type: child.type || token.type, content: child.content });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Split flat tokens at newline boundaries so we get per-line arrays.
+ * Each line is an array of { type, content } segments (no newlines).
+ */
+function tokenizeToLines(code, language) {
+    const grammar = prismjs_1.default.languages[language];
+    if (!grammar) {
+        // Grammar not loaded / unknown language — fall back to plain (unstyled) text
+        return code.split('\n').map(line => line.length > 0 ? [{ type: null, content: line }] : []);
+    }
+    const tokens = prismjs_1.default.tokenize(code, grammar);
+    const flat = flattenTokens(tokens);
+    const lines = [[]];
+    for (const seg of flat) {
+        const parts = seg.content.split('\n');
+        for (let i = 0; i < parts.length; i++) {
+            if (parts[i].length > 0) {
+                lines[lines.length - 1].push({ type: seg.type, content: parts[i] });
+            }
+            if (i < parts.length - 1) {
+                lines.push([]);
+            }
+        }
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Render syntax-highlighted code into a PDFKit document.
+ *
+ * @param doc       PDFKit document instance
+ * @param code      Source code string
+ * @param opts      Rendering options
+ * @returns The Y position immediately after the rendered block
+ */
+function renderCode(doc, code, opts) {
+    const { language = 'javascript', x, y, font = 'Courier', fontSize = 10, lineHeight = 1.5, padding = 12, lineNumbers = true, drawBackground = true, } = opts;
+    const theme = opts.theme
+        ? {
+            ...styles_js_1.defaultSyntaxHighlightTheme,
+            tokens: { ...styles_js_1.defaultSyntaxHighlightTheme.tokens, ...(opts.theme.tokens || {}) },
+            ...opts.theme,
+        }
+        : styles_js_1.defaultSyntaxHighlightTheme;
+    const blockWidth = opts.width || doc.page.width - x - doc.page.margins.right;
+    const lineH = fontSize * lineHeight;
+    // Normalize tabs → 2 spaces
+    const normalized = code.replace(/\t/g, '  ');
+    const lines = tokenizeToLines(normalized, language);
+    // Gutter width (only if line numbers enabled)
+    const gutterWidth = lineNumbers
+        ? doc.widthOfString(String(lines.length), { font, size: fontSize }) + 16
+        : 0;
+    const codeX = x + padding + gutterWidth;
+    const blockHeight = lines.length * lineH + padding * 2;
+    // --- Background ---
+    if (drawBackground) {
+        doc
+            .save()
+            .rect(x, y, blockWidth, blockHeight)
+            .fill(theme.background);
+        doc.restore();
+    }
+    // --- Set font once ---
+    if (font !== 'Courier' && font !== 'Courier-Bold') {
+        // Assume it's a path to an embedded font registered by the caller,
+        // or register it here if it looks like a file path
+        doc.font(font).fontSize(fontSize);
+    }
+    else {
+        doc.font('Courier').fontSize(fontSize);
+    }
+    let curY = y + padding;
+    for (let i = 0; i < lines.length; i++) {
+        const lineTokens = lines[i];
+        // Check for page overflow
+        if (curY + lineH > doc.page.height - doc.page.margins.bottom) {
+            doc.addPage();
+            curY = doc.page.margins.top;
+            // Optionally redraw background on new page — left to caller
+        }
+        // --- Line number ---
+        if (lineNumbers) {
+            doc.fillColor(theme.gutter).text(String(i + 1), x + padding, curY, {
+                lineBreak: false,
+                width: gutterWidth - 8,
+                align: 'right',
+            });
+        }
+        // --- Code tokens ---
+        let curX = codeX;
+        for (const seg of lineTokens) {
+            if (!seg.content)
+                continue;
+            const color = colorFor(seg.type, theme);
+            const segWidth = doc.widthOfString(seg.content);
+            doc.fillColor(color).text(seg.content, curX, curY, {
+                lineBreak: false,
+                continued: false,
+            });
+            curX += segWidth;
+        }
+        curY += lineH;
+    }
+    // Reset fill color to black for subsequent content
+    doc.fillColor('black');
+    return curY + padding; // return Y after block
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { TextStyle, PageLayout, CodeStyle, CodeBlockStyle, BlockquoteStyle, TableStyles, TokenColors, SyntaxHighlightTheme, ThemeConfig, PdfOptions, ColorEmojiRenderer, } from './types.js';
+export { defaultTheme, defaultPageLayout, defaultSyntaxHighlightTheme } from './styles.js';
+export { renderMarkdownToPdf as generatePdf, renderMarkdownToPdf, } from "./renderer.js";
+export { createBrowserImageRenderer } from './browser-image-renderer.js';
+export { createNodeImageRenderer } from './node-image-renderer.js';
+export { createBrowserColorEmojiRenderer } from './color-emoji.js';
+export { createNodeColorEmojiRenderer } from './node-color-emoji.js';
+export { loadHighlightLanguages } from './highlight.prism.js';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHighlightLanguages = exports.createNodeColorEmojiRenderer = exports.createBrowserColorEmojiRenderer = exports.createNodeImageRenderer = exports.createBrowserImageRenderer = exports.renderMarkdownToPdf = exports.generatePdf = exports.defaultSyntaxHighlightTheme = exports.defaultPageLayout = exports.defaultTheme = void 0;
+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; } });
+Object.defineProperty(exports, "defaultSyntaxHighlightTheme", { enumerable: true, get: function () { return styles_js_1.defaultSyntaxHighlightTheme; } });
+var renderer_js_1 = require("./renderer.js");
+Object.defineProperty(exports, "generatePdf", { enumerable: true, get: function () { return renderer_js_1.renderMarkdownToPdf; } });
+Object.defineProperty(exports, "renderMarkdownToPdf", { enumerable: true, get: function () { return renderer_js_1.renderMarkdownToPdf; } });
+var browser_image_renderer_js_1 = require("./browser-image-renderer.js");
+Object.defineProperty(exports, "createBrowserImageRenderer", { enumerable: true, get: function () { return browser_image_renderer_js_1.createBrowserImageRenderer; } });
+var node_image_renderer_js_1 = require("./node-image-renderer.js");
+Object.defineProperty(exports, "createNodeImageRenderer", { enumerable: true, get: function () { return node_image_renderer_js_1.createNodeImageRenderer; } });
+var color_emoji_js_1 = require("./color-emoji.js");
+Object.defineProperty(exports, "createBrowserColorEmojiRenderer", { enumerable: true, get: function () { return color_emoji_js_1.createBrowserColorEmojiRenderer; } });
+var node_color_emoji_js_1 = require("./node-color-emoji.js");
+Object.defineProperty(exports, "createNodeColorEmojiRenderer", { enumerable: true, get: function () { return node_color_emoji_js_1.createNodeColorEmojiRenderer; } });
+var highlight_prism_js_1 = require("./highlight.prism.js");
+Object.defineProperty(exports, "loadHighlightLanguages", { enumerable: true, get: function () { return highlight_prism_js_1.loadHighlightLanguages; } });

package/dist/node-color-emoji.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Node.js color emoji renderer using `@resvg/resvg-js`.
+ *
+ * Separated from `color-emoji.ts` so that the browser entry point
+ * (`src/browser.ts`) can import the shared helpers and browser factory
+ * without pulling in the native `@resvg/resvg-js` addon.
+ */
+import type { ColorEmojiRenderer } from './color-emoji.js';
+/**
+ * Creates a color-emoji renderer for **Node.js** using `@resvg/resvg-js`.
+ *
+ * Fetches Twemoji SVGs over HTTPS on first use and caches the resulting
+ * PNGs for the lifetime of the returned function.
+ */
+export declare function createNodeColorEmojiRenderer(): ColorEmojiRenderer;

package/dist/node-color-emoji.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Node.js color emoji renderer using `@resvg/resvg-js`.
+ *
+ * Separated from `color-emoji.ts` so that the browser entry point
+ * (`src/browser.ts`) can import the shared helpers and browser factory
+ * without pulling in the native `@resvg/resvg-js` addon.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeColorEmojiRenderer = createNodeColorEmojiRenderer;
+const color_emoji_js_1 = require("./color-emoji.js");
+/**
+ * Creates a color-emoji renderer for **Node.js** using `@resvg/resvg-js`.
+ *
+ * Fetches Twemoji SVGs over HTTPS on first use and caches the resulting
+ * PNGs for the lifetime of the returned function.
+ */
+function createNodeColorEmojiRenderer() {
+    const cache = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { Resvg } = require('@resvg/resvg-js');
+    function fetchSvg(url) {
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const mod = url.startsWith('https') ? require('https') : require('http');
+            mod.get(url, (res) => {
+                if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    res.resume();
+                    fetchSvg(res.headers.location).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', (c) => chunks.push(c));
+                res.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+                res.on('error', reject);
+            }).on('error', reject);
+        });
+    }
+    return async (emoji) => {
+        const hit = cache.get(emoji);
+        if (hit)
+            return hit;
+        const svg = await fetchSvg((0, color_emoji_js_1.twemojiSvgUrl)(emoji));
+        const sized = (0, color_emoji_js_1.sizeSvg)(svg, color_emoji_js_1.EMOJI_RENDER_SIZE);
+        const resvg = new Resvg(Buffer.from(sized), {
+            fitTo: { mode: 'width', value: color_emoji_js_1.EMOJI_RENDER_SIZE },
+        });
+        const png = Buffer.from(resvg.render().asPng());
+        cache.set(emoji, png);
+        return png;
+    };
+}

package/dist/node-image-renderer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a Node.js-based image renderer that supports:
+ * - Remote images (http/https)
+ * - Local file system images
+ * - SVG to PNG conversion
+ *
+ * @param basePath - Base directory for resolving relative image paths
+ * @returns A function that takes an image URL/path and returns a Buffer
+ */
+export declare function createNodeImageRenderer(basePath?: string): (imageUrl: string) => Promise<Buffer>;

package/dist/node-image-renderer.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeImageRenderer = createNodeImageRenderer;
+const resvg_js_1 = require("@resvg/resvg-js");
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const defaults_1 = require("./defaults");
+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`));
+        });
+    });
+}
+/**
+ * Creates a Node.js-based image renderer that supports:
+ * - Remote images (http/https)
+ * - Local file system images
+ * - SVG to PNG conversion
+ *
+ * @param basePath - Base directory for resolving relative image paths
+ * @returns A function that takes an image URL/path and returns a Buffer
+ */
+function createNodeImageRenderer(basePath = process.cwd()) {
+    return async (imageUrl) => {
+        let imgBuffer;
+        if (imageUrl.startsWith('http://') || imageUrl.startsWith('https://')) {
+            // Remote image - fetch via HTTP/HTTPS
+            imgBuffer = await fetchImageBuffer(imageUrl);
+        }
+        else {
+            // Local file path — resolve relative to the basePath
+            const imgPath = path_1.default.resolve(basePath, imageUrl);
+            imgBuffer = fs_1.default.readFileSync(imgPath);
+        }
+        // Convert SVG to PNG since pdfkit doesn't support SVG natively
+        if (isSvg(imgBuffer)) {
+            imgBuffer = convertSvgToPng(imgBuffer);
+        }
+        return imgBuffer;
+    };
+}
+defaults_1.DEFAULTS.renderImage = createNodeImageRenderer;

package/dist/renderer.d.ts

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