@speajus/markdown-to-pdf 1.0.4 → 1.0.6

package/README.md

@@ -19,7 +19,7 @@ A lightweight TypeScript library that converts Markdown files into styled PDF do
 ## Installation
 
 ```bash
-npm install
+npm install @speajus/markdown-to-pdf
 ```
 
 ## Quick Start
@@ -29,32 +29,39 @@ npm install
 Convert a Markdown file to PDF from the command line:
 
 ```bash
-npx ts-node src/cli.ts <input.md> [output.pdf]
+# Run directly with npx (no install needed)
+npx @speajus/markdown-to-pdf <input.md> [output.pdf]
+
+# Or if installed globally / as a project dependency
+markdown-to-pdf <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
+npx @speajus/markdown-to-pdf README.md
 
 # Explicit output path
-npx ts-node src/cli.ts docs/report.md output/report.pdf
+npx @speajus/markdown-to-pdf docs/report.md output/report.pdf
 ```
 
 ### Programmatic API
 
 ```typescript
-import { generatePdf } from './src/index';
+import { generatePdf } from '@speajus/markdown-to-pdf';
 
-// File-based — reads Markdown from disk, writes PDF to disk
-await generatePdf('samples/sample.md', 'output/sample.pdf');
+// Returns a PDF Buffer
+const markdown = '# Hello World\n\nThis is a **test**.';
+const pdfBuffer = await generatePdf(markdown);
 
-// Buffer-based — returns a PDF Buffer for further processing
-import { renderMarkdownToPdf } from './src/index';
+// With options
+import { generatePdf, createNodeImageRenderer } from '@speajus/markdown-to-pdf';
 
-const markdown = '# Hello World\n\nThis is a **test**.';
-const pdfBuffer = await renderMarkdownToPdf(markdown);
+const buffer = await generatePdf(markdown, {
+  basePath: '/path/to/markdown/directory',
+  renderImage: createNodeImageRenderer('/path/to/markdown/directory'),
+});
 ```
 
 ### Generate Sample PDFs
@@ -82,9 +89,9 @@ interface PdfOptions {
 ### Page Layout
 
 ```typescript
-import { generatePdf } from './src/index';
+import { generatePdf } from '@speajus/markdown-to-pdf';
 
-await generatePdf('input.md', 'output.pdf', {
+await generatePdf(markdown, {
   pageLayout: {
     pageSize: 'A4',
     margins: { top: 72, right: 72, bottom: 72, left: 72 },
@@ -99,9 +106,9 @@ The default layout uses **Letter** page size with 50pt margins on all sides.
 Override any part of the default theme to customize the look of the generated PDF:
 
 ```typescript
-import { generatePdf, defaultTheme } from './src/index';
+import { generatePdf, defaultTheme } from '@speajus/markdown-to-pdf';
 
-await generatePdf('input.md', 'output.pdf', {
+await generatePdf(markdown, {
   theme: {
     ...defaultTheme,
     headings: {

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

@@ -0,0 +1,12 @@
+/**
+ * Creates a browser-based image renderer that supports:
+ * - Remote images (http/https) via fetch with <img> + canvas fallback
+ * - Data URLs
+ * - Blob URLs
+ *
+ * SVG images are automatically converted to PNG via Canvas rendering using a
+ * same-origin blob URL so the canvas is never tainted.
+ *
+ * @returns A function that takes an image URL and returns a Buffer
+ */
+export declare const createBrowserImageRenderer: (basePath: string) => (imageUrl: string) => Promise<Buffer<ArrayBufferLike>>;

package/dist/browser-image-renderer.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserImageRenderer = void 0;
+const defaults_js_1 = require("./defaults.js");
+/**
+ * Browser-based image renderer using Canvas API and Fetch API.
+ * This implementation works in browser environments where Node.js APIs are not available.
+ */
+const FETCH_TIMEOUT_MS = 10000;
+/**
+ * Path prefix for the image proxy endpoint.
+ * When running behind a dev server (e.g. Vite) that exposes this endpoint,
+ * remote image URLs are rewritten to go through the proxy so that the
+ * browser fetch is same-origin and avoids CORS restrictions.
+ */
+const IMAGE_PROXY_PREFIX = '/__image_proxy/';
+/**
+ * Fetches an image using the Fetch API and returns the raw bytes as a Buffer.
+ * Works for http/https URLs, blob URLs, and data URLs in modern browsers.
+ *
+ * @param url - Image URL to fetch
+ * @returns A Buffer containing the image data
+ */
+async function fetchImageInBrowser(url) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} fetching ${url}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw new Error(`Timeout fetching ${url} after ${FETCH_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Converts an SVG buffer to PNG by rendering it onto a canvas.
+ * This is necessary because pdfkit doesn't support SVG natively.
+ *
+ * @param svgBuffer - Buffer containing SVG data
+ * @returns A Buffer containing the PNG image data
+ */
+function renderSvgToPng(svgBuffer) {
+    return new Promise((resolve, reject) => {
+        const svgBlob = new Blob([new Uint8Array(svgBuffer)], { type: 'image/svg+xml' });
+        const url = URL.createObjectURL(svgBlob);
+        const img = new Image();
+        const timeoutId = setTimeout(() => {
+            URL.revokeObjectURL(url);
+            reject(new Error(`Timeout rendering SVG after ${FETCH_TIMEOUT_MS}ms`));
+        }, FETCH_TIMEOUT_MS);
+        img.onload = () => {
+            clearTimeout(timeoutId);
+            try {
+                const canvas = document.createElement('canvas');
+                canvas.width = img.naturalWidth || img.width || 300;
+                canvas.height = img.naturalHeight || img.height || 150;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    reject(new Error('Failed to get canvas context'));
+                    URL.revokeObjectURL(url);
+                    return;
+                }
+                ctx.drawImage(img, 0, 0);
+                URL.revokeObjectURL(url);
+                canvas.toBlob((blob) => {
+                    if (!blob) {
+                        reject(new Error('Failed to convert SVG canvas to blob'));
+                        return;
+                    }
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(Buffer.from(reader.result));
+                    reader.onerror = () => reject(new Error('Failed to read SVG blob'));
+                    reader.readAsArrayBuffer(blob);
+                }, 'image/png');
+            }
+            catch (err) {
+                URL.revokeObjectURL(url);
+                reject(err);
+            }
+        };
+        img.onerror = () => {
+            clearTimeout(timeoutId);
+            URL.revokeObjectURL(url);
+            reject(new Error('Failed to load SVG for rendering'));
+        };
+        img.src = url;
+    });
+}
+function isSvg(buf) {
+    const head = buf.subarray(0, 256).toString('utf-8').trimStart();
+    return head.startsWith('<svg') || head.startsWith('<?xml');
+}
+/**
+ * Loads a cross-origin image via an <img> element with crossOrigin="anonymous",
+ * draws it to a canvas, and exports as PNG. This works when the server supports
+ * CORS for <img> requests (many CDNs do) even if fetch() was blocked.
+ *
+ * @param imageUrl - URL of the image
+ * @returns A Buffer containing PNG image data
+ */
+function loadImageViaCanvas(imageUrl) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.crossOrigin = 'anonymous';
+        const timeoutId = setTimeout(() => {
+            reject(new Error(`Timeout loading image: ${imageUrl} after ${FETCH_TIMEOUT_MS}ms`));
+        }, FETCH_TIMEOUT_MS);
+        img.onload = () => {
+            clearTimeout(timeoutId);
+            try {
+                const canvas = document.createElement('canvas');
+                canvas.width = img.naturalWidth || img.width;
+                canvas.height = img.naturalHeight || img.height;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    reject(new Error('Failed to get canvas context'));
+                    return;
+                }
+                ctx.drawImage(img, 0, 0);
+                canvas.toBlob((blob) => {
+                    if (!blob) {
+                        reject(new Error('Failed to convert canvas to blob'));
+                        return;
+                    }
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(Buffer.from(reader.result));
+                    reader.onerror = () => reject(new Error('Failed to read blob'));
+                    reader.readAsArrayBuffer(blob);
+                }, 'image/png');
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        img.onerror = () => {
+            clearTimeout(timeoutId);
+            reject(new Error(`Failed to load image: ${imageUrl}. The server may not support CORS. ` +
+                `To fix this, either serve the image from the same origin, use a CORS proxy, ` +
+                `or convert it to a data URL before passing it to the renderer.`));
+        };
+        img.src = imageUrl;
+    });
+}
+/**
+ * Loads an image in the browser and returns it as a Buffer.
+ *
+ * Strategy:
+ * 1. Try fetch() — works for same-origin, data/blob URLs, and CORS-enabled servers.
+ * 2. If fetch fails (CORS), fall back to <img crossOrigin="anonymous"> + canvas,
+ *    which works for servers that support CORS on image requests.
+ * 3. If both fail, throw a descriptive error with remediation steps.
+ *
+ * SVG images are rasterized to PNG via a same-origin blob URL on a canvas.
+ *
+ * @param basePath - Base path (unused in browser, kept for API compatibility)
+ * @param imageUrl - URL of the image (http/https/data/blob URL)
+ * @returns A Buffer containing the image data
+ */
+async function loadImageInBrowser(_basePath, imageUrl) {
+    // For remote URLs, try the same-origin image proxy first (avoids CORS entirely).
+    const isRemote = imageUrl.startsWith('http://') || imageUrl.startsWith('https://');
+    const proxyUrl = isRemote
+        ? `${IMAGE_PROXY_PREFIX}${encodeURIComponent(imageUrl)}`
+        : imageUrl;
+    try {
+        const imgBuffer = await fetchImageInBrowser(proxyUrl);
+        // SVGs must be rasterized to PNG for pdfkit
+        if (isSvg(imgBuffer)) {
+            return renderSvgToPng(imgBuffer);
+        }
+        return imgBuffer;
+    }
+    catch {
+        // Proxy or fetch failed — fall back to <img crossOrigin="anonymous"> + canvas.
+        // This still works when the remote server sends CORS headers for <img> requests.
+        return loadImageViaCanvas(imageUrl);
+    }
+}
+/**
+ * Creates a browser-based image renderer that supports:
+ * - Remote images (http/https) via fetch with <img> + canvas fallback
+ * - Data URLs
+ * - Blob URLs
+ *
+ * SVG images are automatically converted to PNG via Canvas rendering using a
+ * same-origin blob URL so the canvas is never tainted.
+ *
+ * @returns A function that takes an image URL and returns a Buffer
+ */
+const createBrowserImageRenderer = (basePath) => loadImageInBrowser.bind(null, basePath);
+exports.createBrowserImageRenderer = createBrowserImageRenderer;
+defaults_js_1.DEFAULTS.renderImage = exports.createBrowserImageRenderer;

package/dist/browser.d.ts

@@ -0,0 +1,6 @@
+export { createBrowserImageRenderer } from "./browser-image-renderer.js";
+export { createBrowserColorEmojiRenderer } from './color-emoji.js';
+export type { TextStyle, PageLayout, CodeStyle, CodeBlockStyle, BlockquoteStyle, TableStyles, TokenColors, SyntaxHighlightTheme, ThemeConfig, PdfOptions, ColorEmojiRenderer, } from './types.js';
+export { defaultTheme, defaultPageLayout, defaultSyntaxHighlightTheme } from './styles.js';
+export { themes, modernTheme, academicTheme, minimalTheme, oceanTheme } from './themes/index.js';
+export { renderMarkdownToPdf } from "./renderer.js";

package/dist/browser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdownToPdf = exports.oceanTheme = exports.minimalTheme = exports.academicTheme = exports.modernTheme = exports.themes = exports.defaultSyntaxHighlightTheme = exports.defaultPageLayout = exports.defaultTheme = exports.createBrowserColorEmojiRenderer = exports.createBrowserImageRenderer = void 0;
+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 color_emoji_js_1 = require("./color-emoji.js");
+Object.defineProperty(exports, "createBrowserColorEmojiRenderer", { enumerable: true, get: function () { return color_emoji_js_1.createBrowserColorEmojiRenderer; } });
+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 index_js_1 = require("./themes/index.js");
+Object.defineProperty(exports, "themes", { enumerable: true, get: function () { return index_js_1.themes; } });
+Object.defineProperty(exports, "modernTheme", { enumerable: true, get: function () { return index_js_1.modernTheme; } });
+Object.defineProperty(exports, "academicTheme", { enumerable: true, get: function () { return index_js_1.academicTheme; } });
+Object.defineProperty(exports, "minimalTheme", { enumerable: true, get: function () { return index_js_1.minimalTheme; } });
+Object.defineProperty(exports, "oceanTheme", { enumerable: true, get: function () { return index_js_1.oceanTheme; } });
+var renderer_js_1 = require("./renderer.js");
+Object.defineProperty(exports, "renderMarkdownToPdf", { enumerable: true, get: function () { return renderer_js_1.renderMarkdownToPdf; } });

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import type { PdfOptions } from './types.js';
+export declare function readMdWritePdf(inputPath: string, outputPath: string, extraOptions?: Partial<PdfOptions>): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMdWritePdf = readMdWritePdf;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const index_js_1 = require("./index.js");
+async function readMdWritePdf(inputPath, outputPath, extraOptions) {
+    console.log(`Converting ${inputPath} → ${outputPath}`);
+    const resolvedInput = path_1.default.resolve(inputPath);
+    const markdown = fs_1.default.readFileSync(resolvedInput, "utf-8");
+    const basePath = path_1.default.dirname(resolvedInput);
+    // Use Node.js image renderer with the basePath
+    const renderImage = (0, index_js_1.createNodeImageRenderer)(basePath);
+    const buffer = await (0, index_js_1.generatePdf)(markdown, { basePath, renderImage, ...extraOptions });
+    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);
+    console.log(`Done. PDF written to ${path_1.default.resolve(outputPath)}`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.error('Usage: markdown-to-pdf <input.md> [output.pdf]');
+        process.exit(1);
+    }
+    const inputPath = args[0];
+    const outputPath = args[1] || inputPath.replace(/\.md$/i, '.pdf');
+    readMdWritePdf(inputPath, outputPath);
+}
+if (require.main === module) {
+    main().catch((err) => {
+        console.error('Error:', err);
+        process.exit(1);
+    });
+}

package/dist/color-emoji.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Color emoji rendering via SVG → PNG conversion.
+ *
+ * Converts emoji characters to color PNG images using Twemoji SVG assets,
+ * with factory functions for Node.js and browser environments.
+ */
+/** Pixel size at which emoji PNGs are rasterised (scaled to font size by PDFKit). */
+export declare const EMOJI_RENDER_SIZE = 128;
+/**
+ * Convert an emoji string to its Twemoji SVG filename (without extension).
+ *
+ * Twemoji filenames use lower-case hex codepoints separated by hyphens,
+ * with the variation selector U+FE0F omitted.
+ *
+ * @example
+ *   emojiToTwemojiCodepoints('🎉')        // '1f389'
+ *   emojiToTwemojiCodepoints('👨‍👩‍👧‍👦') // '1f468-200d-1f469-200d-1f467-200d-1f466'
+ */
+export declare function emojiToTwemojiCodepoints(emoji: string): string;
+/** Build the full Twemoji CDN URL for a single emoji. */
+export declare function twemojiSvgUrl(emoji: string): string;
+/** Ensure the SVG has explicit pixel dimensions for consistent rasterisation. */
+export declare function sizeSvg(svg: string, size: number): string;
+/** Converts a single emoji string to a PNG `Buffer`. */
+export type ColorEmojiRenderer = (emoji: string) => Promise<Buffer>;
+/**
+ * Creates a color-emoji renderer for **browser** environments.
+ *
+ * Fetches Twemoji SVGs via `fetch()`, rasterises them on a `<canvas>`, and
+ * returns a PNG `Buffer`. Results are cached.
+ */
+export declare function createBrowserColorEmojiRenderer(): ColorEmojiRenderer;
+/**
+ * Scans the full markdown text for all unique emoji and pre-renders them to
+ * PNG `Buffer`s.  The returned `Map` allows `renderTextWithEmoji` to stay
+ * synchronous during rendering.
+ *
+ * @param text     The raw markdown (or any text) to scan.
+ * @param renderer A `ColorEmojiRenderer` (Node.js or browser factory).
+ * @param emojiRe  The emoji-matching regex (from `emoji.ts`).
+ * @returns A `Map` from individual emoji string → PNG Buffer.
+ */
+export declare function preRenderEmoji(text: string, renderer: ColorEmojiRenderer, emojiRe: RegExp): Promise<Map<string, Buffer>>;

package/dist/color-emoji.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Color emoji rendering via SVG → PNG conversion.
+ *
+ * Converts emoji characters to color PNG images using Twemoji SVG assets,
+ * with factory functions for Node.js and browser environments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMOJI_RENDER_SIZE = void 0;
+exports.emojiToTwemojiCodepoints = emojiToTwemojiCodepoints;
+exports.twemojiSvgUrl = twemojiSvgUrl;
+exports.sizeSvg = sizeSvg;
+exports.createBrowserColorEmojiRenderer = createBrowserColorEmojiRenderer;
+exports.preRenderEmoji = preRenderEmoji;
+/**
+ * Twemoji SVG CDN base URL.
+ * Uses the community-maintained fork (`jdecked/twemoji`) since the original
+ * Twitter project was discontinued.
+ */
+const TWEMOJI_BASE = 'https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/';
+/** Pixel size at which emoji PNGs are rasterised (scaled to font size by PDFKit). */
+exports.EMOJI_RENDER_SIZE = 128;
+// ── Codepoint helpers ──────────────────────────────────────────────────────
+/**
+ * Convert an emoji string to its Twemoji SVG filename (without extension).
+ *
+ * Twemoji filenames use lower-case hex codepoints separated by hyphens,
+ * with the variation selector U+FE0F omitted.
+ *
+ * @example
+ *   emojiToTwemojiCodepoints('🎉')        // '1f389'
+ *   emojiToTwemojiCodepoints('👨‍👩‍👧‍👦') // '1f468-200d-1f469-200d-1f467-200d-1f466'
+ */
+function emojiToTwemojiCodepoints(emoji) {
+    const cps = [];
+    for (const ch of emoji) {
+        const cp = ch.codePointAt(0);
+        if (cp === undefined)
+            continue;
+        // Twemoji filenames omit VS16 (U+FE0F)
+        if (cp === 0xfe0f)
+            continue;
+        cps.push(cp.toString(16));
+    }
+    return cps.join('-');
+}
+/** Build the full Twemoji CDN URL for a single emoji. */
+function twemojiSvgUrl(emoji) {
+    return `${TWEMOJI_BASE}${emojiToTwemojiCodepoints(emoji)}.svg`;
+}
+// ── SVG sizing ─────────────────────────────────────────────────────────────
+/** Ensure the SVG has explicit pixel dimensions for consistent rasterisation. */
+function sizeSvg(svg, size) {
+    // Replace existing width/height attributes …
+    let out = svg;
+    if (/width="[^"]*"/.test(out)) {
+        out = out.replace(/width="[^"]*"/, `width="${size}"`);
+        out = out.replace(/height="[^"]*"/, `height="${size}"`);
+        return out;
+    }
+    // … or insert them.
+    return out.replace('<svg', `<svg width="${size}" height="${size}"`);
+}
+// ── Browser factory ─────────────────────────────────────────────────────────
+/**
+ * Creates a color-emoji renderer for **browser** environments.
+ *
+ * Fetches Twemoji SVGs via `fetch()`, rasterises them on a `<canvas>`, and
+ * returns a PNG `Buffer`. Results are cached.
+ */
+function createBrowserColorEmojiRenderer() {
+    const cache = new Map();
+    return async (emoji) => {
+        const hit = cache.get(emoji);
+        if (hit)
+            return hit;
+        const url = twemojiSvgUrl(emoji);
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} fetching ${url}`);
+        const svgText = await res.text();
+        const sized = sizeSvg(svgText, exports.EMOJI_RENDER_SIZE);
+        // Render SVG → Canvas → PNG Blob → Buffer
+        const png = await new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                const canvas = document.createElement('canvas');
+                canvas.width = exports.EMOJI_RENDER_SIZE;
+                canvas.height = exports.EMOJI_RENDER_SIZE;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    reject(new Error('Canvas 2D context unavailable'));
+                    return;
+                }
+                ctx.drawImage(img, 0, 0, exports.EMOJI_RENDER_SIZE, exports.EMOJI_RENDER_SIZE);
+                canvas.toBlob((blob) => {
+                    if (!blob) {
+                        reject(new Error('toBlob failed'));
+                        return;
+                    }
+                    blob.arrayBuffer().then((ab) => resolve(Buffer.from(ab)), reject);
+                }, 'image/png');
+            };
+            img.onerror = () => reject(new Error(`Failed to load SVG as image: ${url}`));
+            img.src = `data:image/svg+xml;base64,${btoa(sized)}`;
+        });
+        cache.set(emoji, png);
+        return png;
+    };
+}
+// ── Pre-render helper ───────────────────────────────────────────────────────
+/**
+ * Scans the full markdown text for all unique emoji and pre-renders them to
+ * PNG `Buffer`s.  The returned `Map` allows `renderTextWithEmoji` to stay
+ * synchronous during rendering.
+ *
+ * @param text     The raw markdown (or any text) to scan.
+ * @param renderer A `ColorEmojiRenderer` (Node.js or browser factory).
+ * @param emojiRe  The emoji-matching regex (from `emoji.ts`).
+ * @returns A `Map` from individual emoji string → PNG Buffer.
+ */
+async function preRenderEmoji(text, renderer, emojiRe) {
+    const unique = new Set();
+    emojiRe.lastIndex = 0;
+    let m;
+    while ((m = emojiRe.exec(text)) !== null) {
+        unique.add(m[0]);
+    }
+    const map = new Map();
+    // Render all unique emoji in parallel
+    await Promise.all([...unique].map(async (emoji) => {
+        try {
+            const png = await renderer(emoji);
+            map.set(emoji, png);
+        }
+        catch {
+            // If a specific emoji fails (missing from Twemoji), skip it —
+            // it will fall back to the monochrome font or the body font.
+        }
+    }));
+    return map;
+}

package/dist/defaults.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULTS: {
+    renderImage: (basePath: string) => (imageUrl: string) => Promise<Buffer>;
+};

package/dist/defaults.js

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

package/dist/emoji.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+export interface TextSegment {
+    text: string;
+    isEmoji: boolean;
+}
+/**
+ * Returns `true` when the whole string is emoji (one or more).
+ */
+export declare function isEmoji(text: string): boolean;
+/**
+ * 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 },
+ *      ]
+ */
+export declare function splitEmojiSegments(text: string): TextSegment[];
+/**
+ * Quick check: does the string contain at least one emoji?
+ */
+export declare function containsEmoji(text: string): boolean;
+/**
+ * Returns the module-level emoji regex.  Useful for external callers
+ * (e.g. `preRenderEmoji`) that need to scan text with the same pattern.
+ */
+export declare function getEmojiRegex(): RegExp;