@polotno/pdf-export 0.1.22 → 0.1.24

package/lib/browser-entry.d.ts

@@ -0,0 +1,7 @@
+import type { PolotnoJSON, RenderAttrs } from './core/index.js';
+export type { PolotnoJSON, RenderAttrs } from './core/index.js';
+export interface BrowserExportOptions {
+    fileName?: string;
+    attrs?: RenderAttrs;
+}
+export declare function jsonToPDF(json: PolotnoJSON, options?: BrowserExportOptions): Promise<Blob>;

package/lib/browser-entry.js

@@ -0,0 +1,11 @@
+import { setPlatformAdapter, hasPlatformAdapter } from './platform/adapter.js';
+import { createBrowserAdapter } from './platform/browser.js';
+import { jsonToPDF as coreJsonToPDF } from './core/index.js';
+if (!hasPlatformAdapter()) {
+    setPlatformAdapter(createBrowserAdapter());
+}
+export async function jsonToPDF(json, options = {}) {
+    const { fileName, attrs } = options;
+    const result = await coreJsonToPDF(json, fileName, attrs ?? {});
+    return result;
+}

package/lib/core/index.d.ts

@@ -0,0 +1,26 @@
+import { SpotColorConfig } from '../spot-colors.js';
+export interface PolotnoJSON {
+    width: number;
+    height: number;
+    fonts: Array<{
+        fontFamily: string;
+        url: string;
+    }>;
+    pages: Array<{
+        background?: string;
+        children: any[];
+    }>;
+}
+export interface RenderAttrs {
+    pdfx1a?: boolean;
+    validate?: boolean;
+    metadata?: {
+        title?: string;
+        author?: string;
+        application?: string;
+        producer?: string;
+    };
+    spotColors?: SpotColorConfig;
+    textVerticalResizeEnabled?: boolean;
+}
+export declare function jsonToPDF(json: PolotnoJSON, pdfFileName?: string, attrs?: RenderAttrs): Promise<Blob | Uint8Array | undefined>;

package/lib/core/index.js

@@ -0,0 +1,87 @@
+import { srcToBuffer, parseColor } from '../utils.js';
+import { renderImage } from '../image.js';
+import { loadFontIfNeeded, renderText } from '../text.js';
+import { renderFigure } from '../figure.js';
+import { renderGroup } from '../group.js';
+import { lineToPDF } from '../line.js';
+import { renderSVG } from '../svg-render.js';
+import { enableSpotColorSupport } from '../spot-colors.js';
+import { getPlatformAdapter } from '../platform/adapter.js';
+async function renderElement({ doc, element, fonts, attrs, cache, }) {
+    if ((element.visible !== undefined && !element.visible) ||
+        (element.showInExport !== undefined && !element.showInExport)) {
+        return;
+    }
+    doc.save();
+    if (element.type !== 'group') {
+        doc.translate(element.x, element.y);
+        doc.rotate(element.rotation);
+    }
+    if (element.opacity !== undefined) {
+        doc.opacity(element.opacity);
+    }
+    if (element.type === 'group') {
+        await renderGroup(doc, element, renderElement, fonts, attrs, cache);
+    }
+    else if (element.type === 'text') {
+        await loadFontIfNeeded(doc, element, fonts);
+        await renderText(doc, element, fonts, attrs);
+    }
+    else if (element.type === 'line') {
+        lineToPDF(doc, element);
+    }
+    else if (element.type === 'image') {
+        await renderImage(doc, element, cache);
+    }
+    else if (element.type === 'svg') {
+        await renderSVG(doc, element, cache);
+    }
+    else if (element.type === 'figure') {
+        renderFigure(doc, element);
+    }
+    doc.restore();
+}
+export async function jsonToPDF(json, pdfFileName, attrs = {}) {
+    const fonts = {};
+    const cache = {
+        images: new Map(),
+        buffers: new Map(),
+        processedImages: new Map(),
+    };
+    const adapter = getPlatformAdapter();
+    const { doc, finalize } = adapter.createPDFContext({
+        size: [json.width, json.height],
+        autoFirstPage: false,
+    });
+    if (attrs.spotColors) {
+        enableSpotColorSupport(doc, attrs.spotColors);
+    }
+    for (const font of json.fonts) {
+        await adapter.registerFont(doc, font.fontFamily, await srcToBuffer(font.url, cache));
+        fonts[font.fontFamily] = true;
+    }
+    for (const page of json.pages) {
+        doc.addPage();
+        if (page.background) {
+            const isURL = page.background.indexOf('http') >= 0 ||
+                page.background.indexOf('.png') >= 0 ||
+                page.background.indexOf('.jpg') >= 0;
+            if (isURL) {
+                const mime = cache.buffers.get(`mime:${page.background}`);
+                await adapter.embedImage(doc, await srcToBuffer(page.background, cache), 0, 0, {
+                    cover: [json.width, json.height],
+                    align: 'center',
+                }, mime);
+            }
+            else {
+                doc.rect(0, 0, json.width, json.height);
+                doc.fill(parseColor(page.background).hex);
+            }
+        }
+        for (const element of page.children) {
+            await renderElement({ doc, element, fonts, attrs, cache });
+        }
+    }
+    doc.end();
+    return finalize({ fileName: pdfFileName, attrs });
+}

package/lib/filters.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from "konva/lib/Node";
+export declare const elementFilterToKonva: Record<string, (intensity: number) => Filter>;

package/lib/filters.js

@@ -0,0 +1,163 @@
+export const elementFilterToKonva = {
+    warm: (intensity) => (imageData) => {
+        const data = imageData.data; // Access pixel data
+        // Intensity should be in 0-1 range from the model
+        intensity = Math.max(0, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            // Increase red and green values for a warm effect
+            data[i] = Math.min(data[i] + 30 * intensity, 255); // Red channel
+            data[i + 1] = Math.min(data[i + 1] + 15 * intensity, 255); // Green channel
+            // Leave blue unchanged for a warm tone
+        }
+        return imageData;
+    },
+    cold: (intensity) => (imageData) => {
+        const data = imageData.data; // Access pixel data
+        // Intensity should be in 0-1 range from the model
+        intensity = Math.max(0, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            // Adjust red, green, and blue channels
+            data[i] = Math.min(data[i] - 15 * intensity, 255); // Reduce red
+            data[i + 1] = Math.min(data[i + 1] - 10 * intensity, 255); // Slightly reduce green
+            data[i + 2] = Math.min(data[i + 2] + 15 * intensity, 255); // Boost blue
+        }
+        return imageData;
+    },
+    natural: (intensity) => (imageData) => {
+        const data = imageData.data; // Access pixel data
+        // Intensity should be in 0-1 range from the model
+        intensity = Math.max(0, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            // Adjust each channel (R, G, B)
+            data[i] = Math.min(data[i] * (1 + 0.1 * intensity), 255); // Enhance red
+            data[i + 1] = Math.min(data[i + 1] * (1 + 0.1 * intensity), 255); // Enhance green
+            data[i + 2] = Math.min(data[i + 2] * (1 + 0.1 * intensity), 255); // Enhance blue
+            // Increase contrast based on intensity
+            const average = (data[i] + data[i + 1] + data[i + 2]) / 3;
+            data[i] = Math.min((data[i] - average) * (1 + 0.2 * intensity) + average, 255);
+            data[i + 1] = Math.min((data[i + 1] - average) * (1 + 0.2 * intensity) + average, 255);
+            data[i + 2] = Math.min((data[i + 2] - average) * (1 + 0.2 * intensity) + average, 255);
+        }
+        return imageData;
+    },
+    temperature: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            // Adjust red and blue channels based on temperature
+            // Warmer = more red, less blue
+            // Colder = more blue, less red
+            data[i] = Math.min(Math.max(r + 15 * intensity, 0), 255); // Red channel
+            data[i + 2] = Math.min(Math.max(b - 15 * intensity, 0), 255); // Blue channel
+            // Optionally: slight tweak to green for balance (optional)
+            // data[i + 1] = Math.min(Math.max(g + 10 * intensity, 0), 255);
+        }
+        return imageData;
+    },
+    contrast: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        // Convert intensity to a contrast factor
+        // Scale from -1,1 to -100,100 for the formula
+        const scaledIntensity = intensity * 100;
+        const factor = (259 * (scaledIntensity + 255)) / (255 * (259 - scaledIntensity));
+        for (let i = 0; i < data.length; i += 4) {
+            // Apply contrast formula to R, G, B channels
+            data[i] = Math.min(Math.max(factor * (data[i] - 128) + 128, 0), 255); // Red
+            data[i + 1] = Math.min(Math.max(factor * (data[i + 1] - 128) + 128, 0), 255); // Green
+            data[i + 2] = Math.min(Math.max(factor * (data[i + 2] - 128) + 128, 0), 255); // Blue
+        }
+        return imageData;
+    },
+    shadows: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            // Compute brightness as average of R, G, B
+            const brightness = (data[i] + data[i + 1] + data[i + 2]) / 3;
+            // Only affect pixels in shadow range (brightness < 128)
+            if (brightness < 128) {
+                const factor = 1 + intensity * (1 - brightness / 128) * 2; // More adjustment for darker pixels
+                data[i] = Math.min(Math.max(data[i] * factor, 0), 255); // Red
+                data[i + 1] = Math.min(Math.max(data[i + 1] * factor, 0), 255); // Green
+                data[i + 2] = Math.min(Math.max(data[i + 2] * factor, 0), 255); // Blue
+            }
+        }
+        return imageData;
+    },
+    white: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const brightness = (r + g + b) / 3;
+            if (brightness > 128) {
+                const factor = 1 + intensity * ((brightness - 128) / 127); // stronger effect on brighter pixels
+                data[i] = Math.min(Math.max(r * factor, 0), 255);
+                data[i + 1] = Math.min(Math.max(g * factor, 0), 255);
+                data[i + 2] = Math.min(Math.max(b * factor, 0), 255);
+            }
+        }
+        return imageData;
+    },
+    black: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const brightness = (r + g + b) / 3;
+            if (brightness < 128) {
+                const factor = 1 + intensity * ((128 - brightness) / 128); // stronger effect on darker pixels
+                data[i] = Math.min(Math.max(r * factor, 0), 255);
+                data[i + 1] = Math.min(Math.max(g * factor, 0), 255);
+                data[i + 2] = Math.min(Math.max(b * factor, 0), 255);
+            }
+        }
+        return imageData;
+    },
+    vibrance: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const max = Math.max(r, g, b);
+            const avg = (r + g + b) / 3;
+            const saturation = max === 0 ? 0 : (max - avg) / max;
+            const factor = intensity < 0 ? (1 - saturation) * intensity * 1.5 : intensity * 0.5;
+            data[i] = Math.min(Math.max(r - (max - r) * factor, 0), 255);
+            data[i + 1] = Math.min(Math.max(g - (max - g) * factor, 0), 255);
+            data[i + 2] = Math.min(Math.max(b - (max - b) * factor, 0), 255);
+        }
+        return imageData;
+    },
+    saturation: (intensity) => (imageData) => {
+        const data = imageData.data;
+        // Intensity should be in -1 to 1 range from the model
+        intensity = Math.max(-1, Math.min(1, intensity));
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+            data[i] = Math.min(Math.max(gray + (r - gray) * (1 + intensity), 0), 255);
+            data[i + 1] = Math.min(Math.max(gray + (g - gray) * (1 + intensity), 0), 255);
+            data[i + 2] = Math.min(Math.max(gray + (b - gray) * (1 + intensity), 0), 255);
+        }
+        return imageData;
+    },
+};

package/lib/image.d.ts

@@ -14,8 +14,19 @@ export interface ImageElement {
     flipY?: boolean;
     borderSize?: number;
     borderColor?: string;
+    brightnessEnabled: boolean;
+    brightness: number;
+    grayscaleEnabled: boolean;
+    sepiaEnabled: boolean;
+    blurEnabled: boolean;
+    blurRadius: number;
+    filters: Record<string, ShapeFilter>;
 }
+type ShapeFilter = {
+    intensity: number;
+};
 export declare function getProcessedImageKey(element: ImageElement): string;
 export declare function cropImage(src: string, element: ImageElement, cache?: ImageCache | null): Promise<string>;
 export declare function clipImage(src: string, element: ImageElement, cache?: ImageCache | null): Promise<string>;
 export declare function renderImage(doc: PDFKit.PDFDocument, element: ImageElement, cache?: ImageCache | null): Promise<void>;
+export {};

package/lib/image.js

@@ -1,9 +1,11 @@
-import { loadImage, PIXEL_RATIO, srcToBuffer, parseColor } from './utils.js';
+import { loadImage, PIXEL_RATIO, srcToBuffer, parseColor, } from './utils.js';
 import Canvas from 'canvas';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
+import Konva from 'konva';
+import { elementFilterToKonva } from './filters.js';
 async function applyFlip(image, element) {
     const { flipX, flipY } = element;
     if (!flipX && !flipY) {
@@ -31,6 +33,13 @@ export function getProcessedImageKey(element) {
         cropWidth: element.cropWidth,
         cropHeight: element.cropHeight,
         clipSrc: element.clipSrc,
+        brightnessEnabled: element.brightnessEnabled,
+        brightness: element.brightness,
+        grayscaleEnabled: element.grayscaleEnabled,
+        sepiaEnabled: element.sepiaEnabled,
+        blurEnabled: element.blurEnabled,
+        blurRadius: element.blurRadius,
+        filters: element.filters,
     });
 }
 export async function cropImage(src, element, cache = null) {
@@ -79,6 +88,44 @@ export async function clipImage(src, element, cache = null) {
     ctx.globalCompositeOperation = 'source-over';
     return canvas.toDataURL('image/png');
 }
+async function applyFilter(src, element, cache = null) {
+    const image = await loadImage(src, cache);
+    const canvas = Canvas.createCanvas(element.width * PIXEL_RATIO, element.height * PIXEL_RATIO);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const data = imageData.data;
+    if (element.brightnessEnabled) {
+        Konva.Filters.Brighten.bind({
+            brightness: () => element.brightness,
+        })({ data });
+    }
+    // grayscale
+    if (element.grayscaleEnabled) {
+        Konva.Filters.Grayscale.bind({})({ data });
+    }
+    // sepia
+    if (element.sepiaEnabled) {
+        Konva.Filters.Sepia.bind({})({ data });
+    }
+    // blur
+    if (element.blurEnabled) {
+        Konva.Filters.Blur.bind({
+            blurRadius: () => element.blurRadius,
+        })({ data });
+    }
+    // filters
+    if (element.filters) {
+        Object.entries(element.filters).forEach(([type, effect]) => {
+            const filter = elementFilterToKonva[type];
+            if (filter) {
+                filter(effect.intensity).bind({})({ data });
+            }
+        });
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas.toDataURL('image/png');
+}
 function applyBorder(doc, element) {
     if (element.borderSize > 0) {
         const borderColor = parseColor(element.borderColor).keyword || 'black';
@@ -99,8 +146,6 @@ export async function renderImage(doc, element, cache = null) {
         doc.image(filePath, 0, 0, {
             width: element.width,
             height: element.height,
-            // No opacity property in pdfkit
-            // opacity: element.opacity,
         });
         applyBorder(doc, element);
         return;
@@ -114,6 +159,7 @@ export async function renderImage(doc, element, cache = null) {
         if (element.clipSrc) {
             src = await clipImage(src, element, cache);
         }
+        src = await applyFilter(src, element, cache);
         // Cache the processed result
         if (cache && src) {
             cache.processedImages.set(cacheKey, src);
@@ -143,7 +189,6 @@ export async function renderImage(doc, element, cache = null) {
         doc.image(filePath, 0, 0, {
             width: element.width,
             height: element.height,
-            // opacity: element.opacity,
         });
         applyBorder(doc, element);
     }

package/lib/platform/adapter.d.ts

@@ -0,0 +1,37 @@
+export interface FetchResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json(): Promise<any>;
+}
+export interface CanvasLike {
+    width: number;
+    height: number;
+    getContext(type: '2d'): any;
+    toDataURL(type?: string, quality?: any): string;
+}
+export interface ImageLike {
+    width: number;
+    height: number;
+    [key: string]: any;
+}
+export interface PDFContext<TOutput = unknown, TFinalizeOptions = unknown> {
+    doc: any;
+    finalize(options?: TFinalizeOptions): Promise<TOutput>;
+}
+export interface PlatformAdapter<TOutput = unknown, TFinalizeOptions = unknown> {
+    fetch(input: string, init?: RequestInit): Promise<FetchResponse>;
+    loadImage(src: string): Promise<ImageLike>;
+    createCanvas(width: number, height: number): CanvasLike;
+    createPDFContext(options: any): PDFContext<TOutput, TFinalizeOptions>;
+    registerFont(doc: any, name: string, data: Uint8Array): void | Promise<void>;
+    encodeBase64(data: Uint8Array): string;
+    decodeBase64(value: string): Uint8Array;
+    embedImage(doc: any, data: Uint8Array | string, x: number, y: number, options: any, mimeType?: string): void | Promise<void>;
+}
+export declare function setPlatformAdapter(adapter: PlatformAdapter): void;
+export declare function hasPlatformAdapter(): boolean;
+export declare function getPlatformAdapter(): PlatformAdapter;

package/lib/platform/adapter.js

@@ -0,0 +1,13 @@
+let currentAdapter = null;
+export function setPlatformAdapter(adapter) {
+    currentAdapter = adapter;
+}
+export function hasPlatformAdapter() {
+    return currentAdapter !== null;
+}
+export function getPlatformAdapter() {
+    if (!currentAdapter) {
+        throw new Error('Platform adapter is not configured.');
+    }
+    return currentAdapter;
+}

package/lib/platform/browser-polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/platform/browser-polyfill.js

@@ -0,0 +1,5 @@
+const globalScope = globalThis;
+if (typeof globalScope.global === 'undefined') {
+    globalScope.global = globalScope;
+}
+export {};

package/lib/platform/browser.d.ts

@@ -0,0 +1,7 @@
+import type { PlatformAdapter } from './adapter.js';
+interface FinalizeOptions {
+    fileName?: string;
+    attrs?: any;
+}
+export declare function createBrowserAdapter(): PlatformAdapter<Blob, FinalizeOptions>;
+export {};

package/lib/platform/browser.js

@@ -0,0 +1,145 @@
+import PDFDocument from 'pdfkit/js/pdfkit.standalone.js';
+import SVGtoPDF from 'svg-to-pdfkit';
+import { Buffer } from 'buffer';
+function attachAddSVG(doc) {
+    const existing = doc.addSVG;
+    if (!existing) {
+        doc.addSVG = function (svg, x, y, options) {
+            SVGtoPDF(this, svg, x, y, options);
+            return this;
+        };
+    }
+}
+function arrayBufferToBase64(buffer) {
+    let binary = '';
+    const chunkSize = 8192;
+    for (let i = 0; i < buffer.length; i += chunkSize) {
+        const chunk = buffer.subarray(i, i + chunkSize);
+        binary += String.fromCharCode(...chunk);
+    }
+    return btoa(binary);
+}
+function base64ToUint8Array(value) {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+function loadImageElement(src) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        if (!src.startsWith('data:')) {
+            img.crossOrigin = 'anonymous';
+        }
+        img.onload = () => resolve(img);
+        img.onerror = (error) => reject(error);
+        img.src = src;
+    });
+}
+async function loadImageFromSource(src) {
+    if (src.startsWith('data:')) {
+        return loadImageElement(src);
+    }
+    const fetchImpl = globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) {
+        throw new Error('Global fetch is not available in this environment.');
+    }
+    const response = await fetchImpl(src, { mode: 'cors' });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const blob = await response.blob();
+    const objectUrl = URL.createObjectURL(blob);
+    try {
+        return await loadImageElement(objectUrl);
+    }
+    finally {
+        URL.revokeObjectURL(objectUrl);
+    }
+}
+export function createBrowserAdapter() {
+    return {
+        async fetch(input, init) {
+            const fetchImpl = globalThis.fetch?.bind(globalThis);
+            if (!fetchImpl) {
+                throw new Error('Global fetch is not available in this environment.');
+            }
+            return (await fetchImpl(input, init));
+        },
+        async loadImage(src) {
+            return loadImageFromSource(src);
+        },
+        createCanvas(width, height) {
+            const canvas = document.createElement('canvas');
+            canvas.width = width;
+            canvas.height = height;
+            return canvas;
+        },
+        createPDFContext(options) {
+            const doc = new PDFDocument(options);
+            attachAddSVG(doc);
+            const blobParts = [];
+            const appendTypedArray = (view) => {
+                blobParts.push(view.slice());
+            };
+            doc.on('data', (chunk) => {
+                if (chunk instanceof Uint8Array) {
+                    appendTypedArray(chunk);
+                }
+                else if (Array.isArray(chunk)) {
+                    appendTypedArray(new Uint8Array(chunk));
+                }
+                else if (typeof chunk === 'string') {
+                    const encoder = new TextEncoder();
+                    appendTypedArray(encoder.encode(chunk));
+                }
+                else if (chunk?.buffer instanceof ArrayBuffer) {
+                    appendTypedArray(new Uint8Array(chunk.buffer));
+                }
+            });
+            const resultPromise = new Promise((resolve, reject) => {
+                doc.on('end', () => {
+                    try {
+                        resolve(new Blob(blobParts, { type: 'application/pdf' }));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                doc.on('error', reject);
+            });
+            const finalize = async (options) => {
+                if (options?.attrs?.pdfx1a) {
+                    console.warn('PDF/X-1a conversion is not supported in the browser runtime.');
+                }
+                return resultPromise;
+            };
+            return {
+                doc,
+                finalize,
+            };
+        },
+        registerFont(doc, name, data) {
+            const buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+            doc.registerFont(name, buffer);
+        },
+        encodeBase64(data) {
+            return arrayBufferToBase64(data);
+        },
+        decodeBase64(value) {
+            return base64ToUint8Array(value);
+        },
+        embedImage(doc, data, x, y, options, mimeType) {
+            if (typeof data === 'string') {
+                doc.image(data, x, y, options);
+                return;
+            }
+            const mime = mimeType || 'image/png';
+            const base64 = arrayBufferToBase64(data);
+            const dataUrl = `data:${mime};base64,${base64}`;
+            doc.image(dataUrl, x, y, options);
+        },
+    };
+}

package/lib/platform/node.d.ts

@@ -0,0 +1,7 @@
+import type { PlatformAdapter } from './adapter.js';
+interface FinalizeOptions {
+    fileName?: string;
+    attrs?: any;
+}
+export declare function createNodeAdapter(): PlatformAdapter<Uint8Array, FinalizeOptions>;
+export {};

package/lib/platform/node.js

@@ -0,0 +1,142 @@
+import fs from 'fs';
+import { Buffer } from 'buffer';
+import { PassThrough } from 'stream';
+import PDFDocument from 'pdfkit';
+import SVGtoPDF from 'svg-to-pdfkit';
+import Canvas from 'canvas';
+import sharp from 'sharp';
+import nodeFetch from 'node-fetch';
+import { fileTypeFromBuffer } from 'file-type';
+import { convertToPDFX1a, validatePDFX1a } from '../ghostscript.js';
+function ensureBuffer(data) {
+    return Buffer.isBuffer(data) ? data : Buffer.from(data);
+}
+function getFetch() {
+    if (typeof globalThis.fetch === 'function') {
+        return globalThis.fetch.bind(globalThis);
+    }
+    return nodeFetch;
+}
+async function convertToPNG(buffer, mime) {
+    if (mime === 'image/png' || mime === 'image/jpeg') {
+        return buffer;
+    }
+    // Fall back to PNG conversion for other formats
+    return sharp(buffer).toFormat('png').toBuffer();
+}
+function attachAddSVG(doc) {
+    const existing = doc.addSVG;
+    if (!existing) {
+        doc.addSVG = function (svg, x, y, options) {
+            SVGtoPDF(this, svg, x, y, options);
+            return this;
+        };
+    }
+}
+async function writeBufferToFile(fileName, buffer) {
+    await fs.promises.writeFile(fileName, buffer);
+}
+export function createNodeAdapter() {
+    const fetchImpl = getFetch();
+    return {
+        async fetch(input, init) {
+            return (await fetchImpl(input, init));
+        },
+        async loadImage(src) {
+            let buffer;
+            let mime;
+            if (src.startsWith('data:')) {
+                const matches = src.match(/^data:(.+);base64,(.*)$/);
+                if (!matches) {
+                    throw new Error('Invalid data URL');
+                }
+                mime = matches[1];
+                buffer = Buffer.from(matches[2], 'base64');
+            }
+            else {
+                const response = await fetchImpl(src);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                buffer = Buffer.from(arrayBuffer);
+                const typeInfo = await fileTypeFromBuffer(buffer);
+                if (typeInfo) {
+                    mime = typeInfo.mime;
+                }
+            }
+            const normalizedBuffer = await convertToPNG(buffer, mime);
+            return Canvas.loadImage(normalizedBuffer);
+        },
+        createCanvas(width, height) {
+            return Canvas.createCanvas(width, height);
+        },
+        createPDFContext(options) {
+            const doc = new PDFDocument(options);
+            attachAddSVG(doc);
+            const stream = doc.pipe(new PassThrough());
+            const chunks = [];
+            stream.on('data', (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            const resultPromise = new Promise((resolve, reject) => {
+                stream.on('end', () => resolve(Buffer.concat(chunks)));
+                stream.on('error', reject);
+                doc.on('error', reject);
+            });
+            const finalize = async (options) => {
+                const buffer = await resultPromise;
+                const outputBuffer = Buffer.from(buffer);
+                if (options?.fileName) {
+                    const targetFile = options.fileName;
+                    await writeBufferToFile(targetFile, outputBuffer);
+                    if (options.attrs?.pdfx1a) {
+                        const tempFile = targetFile.replace('.pdf', '-temp.pdf');
+                        await fs.promises.rename(targetFile, tempFile);
+                        try {
+                            await convertToPDFX1a(tempFile, targetFile, {
+                                metadata: options.attrs.metadata || {},
+                            });
+                            await fs.promises.unlink(tempFile);
+                            if (options.attrs.validate) {
+                                const isValid = await validatePDFX1a(targetFile);
+                                if (!isValid) {
+                                    console.warn('Warning: Generated PDF may not be fully PDF/X-1a compliant');
+                                }
+                            }
+                        }
+                        catch (error) {
+                            if (fs.existsSync(tempFile)) {
+                                await fs.promises.rename(tempFile, targetFile);
+                            }
+                            throw new Error(`PDF/X-1a conversion failed: ${error.message}`);
+                        }
+                    }
+                }
+                return new Uint8Array(outputBuffer);
+            };
+            return {
+                doc,
+                finalize,
+            };
+        },
+        registerFont(doc, name, data) {
+            const buffer = ensureBuffer(data);
+            doc.registerFont(name, buffer);
+        },
+        encodeBase64(data) {
+            return Buffer.from(data).toString('base64');
+        },
+        decodeBase64(value) {
+            return new Uint8Array(Buffer.from(value, 'base64'));
+        },
+        embedImage(doc, data, x, y, options, _mimeType) {
+            if (typeof data === 'string') {
+                doc.image(data, x, y, options);
+                return;
+            }
+            const buffer = ensureBuffer(data);
+            doc.image(buffer, x, y, options);
+        },
+    };
+}

package/lib/text.d.ts

@@ -31,9 +31,15 @@ export interface TextSegment {
     underline?: boolean;
     color?: string;
 }
+/**
+ * Normalize rich text HTML by converting block-level line breaks into newline characters
+ * while preserving inline formatting tags.
+ */
+declare function normalizeRichText(text: string): string;
 export declare function getGoogleFontPath(fontFamily: string, fontWeight?: string, italic?: boolean): Promise<string>;
 export declare function loadFontIfNeeded(doc: any, element: TextElement, fonts: Record<string, boolean>): Promise<string>;
 /**
  * Main text rendering function
  */
 export declare function renderText(doc: PDFKit.PDFDocument, element: TextElement, fonts: Record<string, boolean>, attrs?: RenderAttrs): Promise<void>;
+export { normalizeRichText as __normalizeRichTextForTests };

package/lib/text.js

@@ -1,14 +1,34 @@
 import { parseColor, srcToBuffer } from './utils.js';
 import getUrls from 'get-urls';
 import fetch from 'node-fetch';
-import { stripHtml } from "string-strip-html";
+import { stripHtml } from 'string-strip-html';
 /**
  * Check if text contains HTML tags
  */
 function containsHTML(text) {
-    const htmlTagRegex = /<\/?(?:strong|b|em|i|u|span)[^>]*>/i;
+    const htmlTagRegex = /<\/?(?:strong|b|em|i|u|span|p|br)[^>]*>/i;
     return htmlTagRegex.test(text);
 }
+/**
+ * Normalize rich text HTML by converting block-level line breaks into newline characters
+ * while preserving inline formatting tags.
+ */
+function normalizeRichText(text) {
+    if (!text) {
+        return text;
+    }
+    let normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    // Convert explicit HTML break tags into newline characters
+    normalized = normalized.replace(/<br\s*\/?>/gi, '\n');
+    // Treat paragraph boundaries as newlines and drop opening tags
+    normalized = normalized.replace(/<\/p\s*>/gi, '\n');
+    normalized = normalized.replace(/<p[^>]*>/gi, '');
+    // Collapse excessive consecutive newlines produced by HTML cleanup
+    normalized = normalized.replace(/\n{3,}/g, '\n\n');
+    // Trim stray leading/trailing newlines introduced by paragraph conversion
+    normalized = normalized.replace(/^\n+/, '').replace(/\n+$/, '');
+    return normalized;
+}
 /**
  * Parse HTML text into styled segments
  */
@@ -42,7 +62,7 @@ function parseHTMLToSegments(html, baseElement) {
                 bold,
                 italic,
                 underline,
-                color
+                color,
             });
         }
         else {
@@ -52,7 +72,7 @@ function parseHTMLToSegments(html, baseElement) {
             const attributes = match[3];
             if (isClosing) {
                 // Remove from stack
-                const index = tagStack.findIndex(t => t.tag === tagName);
+                const index = tagStack.findIndex((t) => t.tag === tagName);
                 if (index !== -1) {
                     tagStack.splice(index, 1);
                 }
@@ -157,7 +177,7 @@ function tokenizeHTML(html) {
             // Text content
             tokens.push({
                 type: 'text',
-                content: match[4]
+                content: match[4],
             });
         }
         else {
@@ -168,7 +188,7 @@ function tokenizeHTML(html) {
                 type: 'tag',
                 content: match[0],
                 tagName: tagName,
-                isClosing: isClosing
+                isClosing: isClosing,
             });
         }
     }
@@ -196,7 +216,7 @@ function tokensToHTML(tokens, openTags) {
             html += token.content;
             if (token.isClosing) {
                 // Remove from stack
-                const idx = tagStack.findIndex(t => t.name === token.tagName);
+                const idx = tagStack.findIndex((t) => t.name === token.tagName);
                 if (idx !== -1) {
                     tagStack.splice(idx, 1);
                 }
@@ -205,7 +225,7 @@ function tokensToHTML(tokens, openTags) {
                 // Add to stack
                 tagStack.push({
                     name: token.tagName,
-                    fullTag: token.content
+                    fullTag: token.content,
                 });
             }
         }
@@ -228,8 +248,8 @@ function splitTextIntoLines(doc, element, props) {
         const tokens = tokenizeHTML(paragraph);
         // Extract plain text for width calculation
         const plainText = tokens
-            .filter(t => t.type === 'text')
-            .map(t => t.content)
+            .filter((t) => t.type === 'text')
+            .map((t) => t.content)
             .join('');
         const paragraphWidth = doc.widthOfString(plainText, props);
         // Justify alignment using native pdfkit instruments
@@ -252,7 +272,9 @@ function splitTextIntoLines(doc, element, props) {
                 const textWords = token.content.split(' ');
                 for (let i = 0; i < textWords.length; i++) {
                     const word = textWords[i];
-                    const testLine = currentLine ? `${currentLine}${i > 0 ? ' ' : ''}${word}` : word;
+                    const testLine = currentLine
+                        ? `${currentLine}${i > 0 ? ' ' : ''}${word}`
+                        : word;
                     const testWidth = doc.widthOfString(testLine, props);
                     if (testWidth <= element.width) {
                         currentLine = testLine;
@@ -262,13 +284,13 @@ function splitTextIntoLines(doc, element, props) {
                             let content = (i > 0 ? ' ' : '') + word;
                             currentTokens.push({
                                 type: 'text',
-                                content: content
+                                content: content,
                             });
                         }
                         else {
                             currentTokens.push({
                                 type: 'text',
-                                content: word
+                                content: word,
                             });
                         }
                     }
@@ -284,7 +306,7 @@ function splitTextIntoLines(doc, element, props) {
                         currentWidth = doc.widthOfString(word, props);
                         currentTokens.push({
                             type: 'text',
-                            content: word
+                            content: word,
                         });
                     }
                 }
@@ -334,14 +356,15 @@ function calculateTextMetrics(doc, element) {
             : 0,
         lineBreak: false,
         stroke: false,
-        fill: false
+        fill: false,
     };
     const currentLineHeight = doc.heightOfString('A', textOptions);
     const lineHeight = element.lineHeight * element.fontSize;
     const fontBoundingBoxAscent = (doc._font.ascender / 1000) * element.fontSize;
     const fontBoundingBoxDescent = (doc._font.descender / 1000) * element.fontSize;
     // Calculate baseline offset based on font metrics (similar to Konva rendering)
-    const baselineOffset = (fontBoundingBoxAscent - Math.abs(fontBoundingBoxDescent)) / 2 + lineHeight / 2;
+    const baselineOffset = (fontBoundingBoxAscent - Math.abs(fontBoundingBoxDescent)) / 2 +
+        lineHeight / 2;
     // Adjust line gap to match desired line height
     const lineHeightDiff = currentLineHeight - lineHeight;
     textOptions.lineGap = textOptions.lineGap - lineHeightDiff;
@@ -350,7 +373,7 @@ function calculateTextMetrics(doc, element) {
         textOptions,
         lineHeightPx: lineHeight,
         baselineOffset,
-        textLines
+        textLines,
     };
 }
 /**
@@ -392,7 +415,8 @@ function renderTextBackground(doc, element, verticalAlignmentOffset, textOptions
     }
     const strippedContent = stripHtml(element.text).result;
     const padding = element.backgroundPadding * (element.fontSize * element.lineHeight);
-    const cornerRadius = element.backgroundCornerRadius * (element.fontSize * element.lineHeight * 0.5);
+    const cornerRadius = element.backgroundCornerRadius *
+        (element.fontSize * element.lineHeight * 0.5);
     const textWidth = doc.widthOfString(strippedContent, {
         ...textOptions,
         width: element.width,
@@ -439,7 +463,7 @@ function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, text
     for (let i = 0; i < textLines.length; i++) {
         const line = textLines[i];
         const lineXOffset = calculateLineXOffset(element, line.width);
-        const lineYOffset = yOffset + (i * lineHeightPx);
+        const lineYOffset = yOffset + i * lineHeightPx;
         for (const offset of offsets) {
             doc.text(line.text, lineXOffset + offset.x, lineYOffset + offset.y, {
                 ...textOptions,
@@ -454,7 +478,7 @@ function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, text
     for (let i = 0; i < textLines.length; i++) {
         const line = textLines[i];
         const lineXOffset = calculateLineXOffset(element, line.width);
-        const lineYOffset = yOffset + (i * lineHeightPx);
+        const lineYOffset = yOffset + i * lineHeightPx;
         doc.text(line.text, lineXOffset, lineYOffset, {
             ...textOptions,
             width: isJustify ? element.width : undefined,
@@ -486,7 +510,7 @@ function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, te
             width: isJustify ? element.width : undefined,
             height: heightOfLine,
             stroke: true,
-            fill: false
+            fill: false,
         });
     }
     doc.restore();
@@ -541,7 +565,7 @@ async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, te
                 underline: segment.underline || textOptions.underline || false,
                 lineBreak: !!segment.underline, // Workaround for pdfkit bug
                 stroke: false,
-                fill: true
+                fill: true,
             });
         }
     }
@@ -550,28 +574,36 @@ async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, te
  * Main text rendering function
  */
 export async function renderText(doc, element, fonts, attrs = {}) {
-    doc.fontSize(element.fontSize);
-    const hasStroke = element.strokeWidth > 0;
+    const normalizedText = typeof element.text === 'string'
+        ? normalizeRichText(element.text)
+        : element.text;
+    const elementToRender = typeof element.text === 'string' && normalizedText !== element.text
+        ? { ...element, text: normalizedText }
+        : element;
+    doc.fontSize(elementToRender.fontSize);
+    const hasStroke = elementToRender.strokeWidth > 0;
     const isPDFX1a = attrs.pdfx1a;
     // Calculate text metrics and line positioning
-    const metrics = calculateTextMetrics(doc, element);
-    const verticalAlignmentOffset = calculateVerticalAlignment(doc, element, metrics.textOptions);
+    const metrics = calculateTextMetrics(doc, elementToRender);
+    const verticalAlignmentOffset = calculateVerticalAlignment(doc, elementToRender, metrics.textOptions);
     // Fit text to element height if needed
-    fitTextToHeight(doc, element, metrics.textOptions);
+    fitTextToHeight(doc, elementToRender, metrics.textOptions);
     // Calculate final vertical offset
     const finalYOffset = verticalAlignmentOffset + metrics.baselineOffset;
     // Render background if enabled
-    renderTextBackground(doc, element, verticalAlignmentOffset, metrics.textOptions);
+    renderTextBackground(doc, elementToRender, verticalAlignmentOffset, metrics.textOptions);
     // Render text based on stroke and PDF/X-1a requirements
     if (hasStroke && isPDFX1a) {
         // PDF/X-1a mode: simulate stroke with offset fills
-        renderPDFX1aStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
+        renderPDFX1aStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
     }
     else {
         // Standard rendering: stroke first, then fill
         if (hasStroke) {
-            renderStandardStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
+            renderStandardStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
         }
-        await renderTextFill(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
+        await renderTextFill(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
     }
 }
+// Internal exports for testing
+export { normalizeRichText as __normalizeRichTextForTests };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-export",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Convert Polotno JSON into vector PDF",
   "type": "module",
   "main": "./lib/index.js",