@polotno/pdf-export 0.1.38 → 0.1.40

package/lib/image.js

@@ -1,279 +0,0 @@
-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) {
-        return image;
-    }
-    if (!image || !image.width || !image.height) {
-        return null;
-    }
-    const canvas = new Canvas.Canvas(image.width, image.height);
-    const ctx = canvas.getContext('2d');
-    let x = flipX ? -canvas.width : 0;
-    let y = flipY ? -canvas.height : 0;
-    ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
-    ctx.drawImage(image, x, y, canvas.width, canvas.height);
-    return canvas;
-}
-// Helper to create cache key for processed images
-export function getProcessedImageKey(element) {
-    return JSON.stringify({
-        src: element.src,
-        width: element.width,
-        height: element.height,
-        cropX: element.cropX,
-        cropY: element.cropY,
-        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) {
-    let image = await loadImage(src);
-    // Apply flip transformations first
-    image = await applyFlip(image, element);
-    if (!image) {
-        return null;
-    }
-    const canvas = Canvas.createCanvas(element.width * PIXEL_RATIO, element.height * PIXEL_RATIO);
-    const ctx = canvas.getContext('2d');
-    let { cropX, cropY } = element;
-    const availableWidth = image.width * element.cropWidth;
-    const availableHeight = image.height * element.cropHeight;
-    const aspectRatio = element.width / element.height;
-    let cropAbsoluteWidth;
-    let cropAbsoluteHeight;
-    const imageRatio = availableWidth / availableHeight;
-    const allowScale = element.type === 'svg';
-    if (allowScale) {
-        cropAbsoluteWidth = availableWidth;
-        cropAbsoluteHeight = availableHeight;
-    }
-    else if (aspectRatio >= imageRatio) {
-        cropAbsoluteWidth = availableWidth;
-        cropAbsoluteHeight = availableWidth / aspectRatio;
-    }
-    else {
-        cropAbsoluteWidth = availableHeight * aspectRatio;
-        cropAbsoluteHeight = availableHeight;
-    }
-    ctx.drawImage(image, cropX * image.width, cropY * image.height, cropAbsoluteWidth, cropAbsoluteHeight, 0, 0, canvas.width, canvas.height);
-    return canvas.toDataURL('image/png');
-}
-export async function clipImage(src, element, cache = null) {
-    const image = await loadImage(src, cache);
-    const clipImage = await loadImage(element.clipSrc, cache);
-    const canvas = Canvas.createCanvas(element.width, element.height);
-    const ctx = canvas.getContext('2d');
-    ctx.drawImage(image, 0, 0, element.width, element.height);
-    const clipCanvas = Canvas.createCanvas(element.width, element.height);
-    const clipCtx = clipCanvas.getContext('2d');
-    clipCtx.drawImage(clipImage, 0, 0, element.width, element.height);
-    ctx.globalCompositeOperation = 'destination-in';
-    ctx.drawImage(clipCanvas, 0, 0);
-    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';
-        doc
-            .rect(element.borderSize / 2, element.borderSize / 2, element.width - element.borderSize, element.height - element.borderSize)
-            .lineWidth(element.borderSize)
-            .strokeColor(borderColor)
-            .stroke();
-    }
-}
-function saveToTempFile(buffer, key, cache) {
-    if (cache) {
-        if (!cache.imageFiles) {
-            cache.imageFiles = new Map();
-        }
-        if (!cache.tempDir) {
-            cache.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfkit-images-'));
-        }
-        // Create a unique filename based on cache key hash
-        const hash = crypto.createHash('md5').update(key).digest('hex');
-        const filePath = path.join(cache.tempDir, `${hash}.png`);
-        // Write buffer to file
-        fs.writeFileSync(filePath, buffer);
-        cache.imageFiles.set(key, filePath);
-        return filePath;
-    }
-    else {
-        return buffer;
-    }
-}
-async function getShadowImage(src, element, cache) {
-    const image = await loadImage(src, cache);
-    const { shadowBlur, shadowColor, shadowOpacity } = element;
-    // Shadow blur in Konva is standard. In Canvas it is standard.
-    // We need to scale it by PIXEL_RATIO as our canvas is scaled.
-    const ratio = PIXEL_RATIO;
-    const blur = (shadowBlur || 0) * ratio;
-    // Padding.
-    const padding = blur * 4 + 20; // Sufficient padding
-    const width = image.width + padding * 2;
-    const height = image.height + padding * 2;
-    const canvas = Canvas.createCanvas(width, height);
-    const ctx = canvas.getContext('2d');
-    // Parse color
-    const parsed = parseColor(shadowColor || 'black');
-    const opacity = shadowOpacity !== undefined ? shadowOpacity : 1;
-    const r = parsed.rgb[0];
-    const g = parsed.rgb[1];
-    const b = parsed.rgb[2];
-    const a = opacity;
-    const colorString = `rgba(${r},${g},${b},${a})`;
-    ctx.shadowColor = colorString;
-    ctx.shadowBlur = blur;
-    // We want the shadow to appear at (padding, padding) relative to canvas.
-    // We draw the image at (padding - OFFSET, padding - OFFSET)
-    // And set shadowOffset to (OFFSET, OFFSET).
-    // OFFSET should be large enough to move image out of view.
-    const OFFSET = 10000;
-    ctx.shadowOffsetX = OFFSET;
-    ctx.shadowOffsetY = OFFSET;
-    // Draw image
-    ctx.drawImage(image, padding - OFFSET, padding - OFFSET, image.width, image.height);
-    return {
-        src: canvas.toDataURL('image/png'),
-        padding: padding / ratio, // return padding in original units (points)
-        width: width / ratio,
-        height: height / ratio,
-    };
-}
-export async function renderImage(doc, element, cache = null) {
-    // Check if we have a cached processed version
-    const cacheKey = getProcessedImageKey(element);
-    let src = null;
-    const hasCachedFile = cache && cache.imageFiles && cache.imageFiles.has(cacheKey);
-    if (hasCachedFile) {
-        src = cache.imageFiles.get(cacheKey);
-    }
-    else if (cache && cache.processedImages.has(cacheKey)) {
-        src = cache.processedImages.get(cacheKey);
-    }
-    else {
-        src = await cropImage(element.src, element, cache);
-        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);
-        }
-    }
-    if (element.shadowEnabled && src) {
-        const shadowKey = cacheKey +
-            '_shadow_' +
-            JSON.stringify({
-                blur: element.shadowBlur,
-                color: element.shadowColor,
-                opacity: element.shadowOpacity,
-            });
-        let shadowPadding = 0;
-        let shadowW = 0;
-        let shadowH = 0;
-        if (cache && cache.imageFiles && cache.imageFiles.has(shadowKey)) {
-            const filePath = cache.imageFiles.get(shadowKey);
-            // Recalculate padding/dimensions as we don't cache them
-            const ratio = PIXEL_RATIO;
-            const blur = (element.shadowBlur || 0) * ratio;
-            shadowPadding = (blur * 4 + 20) / ratio;
-            shadowW = element.width + shadowPadding * 2;
-            shadowH = element.height + shadowPadding * 2;
-            console.log('✓ Using cached shadow file:', path.basename(filePath));
-            doc.image(filePath, (element.shadowOffsetX || 0) - shadowPadding, (element.shadowOffsetY || 0) - shadowPadding, {
-                width: shadowW,
-                height: shadowH,
-            });
-        }
-        else {
-            const shadowResult = await getShadowImage(src, element, cache);
-            const shadowSrc = shadowResult.src;
-            shadowPadding = shadowResult.padding;
-            shadowW = shadowResult.width;
-            shadowH = shadowResult.height;
-            if (shadowSrc) {
-                const buffer = await srcToBuffer(shadowSrc, cache);
-                const filePath = saveToTempFile(buffer, shadowKey, cache);
-                doc.image(filePath, (element.shadowOffsetX || 0) - shadowPadding, (element.shadowOffsetY || 0) - shadowPadding, {
-                    width: shadowW,
-                    height: shadowH,
-                });
-            }
-        }
-    }
-    if (src) {
-        if (hasCachedFile) {
-            console.log('✓ Using cached image file:', path.basename(src));
-            doc.image(src, 0, 0, {
-                width: element.width,
-                height: element.height,
-            });
-        }
-        else {
-            const buffer = await srcToBuffer(src, cache);
-            const filePath = saveToTempFile(buffer, cacheKey, cache);
-            doc.image(filePath, 0, 0, {
-                width: element.width,
-                height: element.height,
-            });
-        }
-        applyBorder(doc, element);
-    }
-}

package/lib/line.d.ts

@@ -1,10 +0,0 @@
-export interface LineElement {
-    height: number;
-    width: number;
-    color: string;
-    opacity: number;
-    dash?: number[];
-    startHead?: string;
-    endHead?: string;
-}
-export declare function lineToPDF(doc: any, element: LineElement): void;

package/lib/line.js

@@ -1,66 +0,0 @@
-import { Util } from 'konva/lib/Util.js';
-function rgbToHex({ r, g, b }) {
-    // Ensure each value is within the valid range
-    r = Math.max(0, Math.min(255, r));
-    g = Math.max(0, Math.min(255, g));
-    b = Math.max(0, Math.min(255, b));
-    // Convert each value to a 2-digit hexadecimal string
-    const hexR = r.toString(16).padStart(2, '0');
-    const hexG = g.toString(16).padStart(2, '0');
-    const hexB = b.toString(16).padStart(2, '0');
-    // Return the concatenated hex string
-    return `#${hexR}${hexG}${hexB}`;
-}
-function getLineHead({ element, type, doc }) {
-    doc.lineWidth(element.height);
-    doc.lineCap('round');
-    doc.lineJoin('round');
-    doc.opacity(element.opacity);
-    const rgba = Util.colorToRGBA(element.color);
-    const fillColor = rgbToHex(rgba);
-    if (type === 'arrow') {
-        doc
-            .moveTo(element.height * 3, -element.height * 2)
-            .lineTo(0, 0)
-            .lineTo(element.height * 3, element.height * 2);
-        doc.stroke();
-        return;
-    }
-    else if (type === 'triangle') {
-        doc.polygon([element.height * 3, -element.height * 2], [0, 0], [element.height * 3, element.height * 2]);
-    }
-    else if (type === 'bar') {
-        doc.polygon([0, -element.height * 2], [0, 0], [0, element.height * 2]);
-    }
-    else if (type === 'circle') {
-        doc.circle(element.height * 2, 0, element.height * 2);
-    }
-    else if (type === 'square') {
-        doc.rect(0, -element.height * 2, element.height * 4, element.height * 4);
-    }
-    else {
-        return;
-    }
-    doc.fillAndStroke(fillColor, fillColor);
-}
-export function lineToPDF(doc, element) {
-    doc.translate(0, element.height / 2);
-    doc.lineWidth(element.height);
-    doc.moveTo(0, 0);
-    doc.lineTo(element.width, 0);
-    if (element.dash && element.dash.length > 0) {
-        doc.dash(element.dash.map((dash) => dash * element.height));
-    }
-    const rgba = Util.colorToRGBA(element.color);
-    doc.strokeColor(rgbToHex(rgba));
-    doc.stroke();
-    if (element.dash && element.dash.length > 0) {
-        doc.undash();
-    }
-    getLineHead({ element, doc: doc, type: element.startHead });
-    getLineHead({
-        element,
-        doc: doc.translate(element.width, 0).rotate(180),
-        type: element.endHead,
-    });
-}

package/lib/pdf-import/coordinate-transform.d.ts

@@ -1,51 +0,0 @@
-/**
- * Transform PDF coordinates (bottom-left origin) to Polotno coordinates (top-left origin)
- */
-export declare function pdfToPolotnoY(pdfY: number, elementHeight: number, pageHeight: number): number;
-/**
- * X coordinate remains the same between PDF and Polotno
- */
-export declare function pdfToPolotnoX(pdfX: number): number;
-/**
- * Extract rotation angle from PDF transformation matrix
- * PDF transformation matrix is [a, b, c, d, e, f]
- * where rotation is encoded in a, b, c, d components
- */
-export declare function extractRotation(transform: number[]): number;
-/**
- * Extract scale from PDF transformation matrix
- */
-export declare function extractScale(transform: number[]): {
-    scaleX: number;
-    scaleY: number;
-};
-/**
- * Extract position from PDF transformation matrix
- * Returns position in PDF coordinates (will need to be converted to Polotno)
- */
-export declare function extractPosition(transform: number[]): {
-    x: number;
-    y: number;
-};
-/**
- * Calculate font size from PDF transformation matrix
- * Font size is encoded in the scale component of the matrix
- */
-export declare function calculateFontSize(transform: number[]): number;
-/**
- * Transform a complete bounding box from PDF to Polotno coordinates
- */
-export declare function transformBoundingBox(pdfX: number, pdfY: number, width: number, height: number, pageHeight: number): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-/**
- * Convert PDF color array [r, g, b] (0-1 range) to hex color string
- */
-export declare function pdfColorToHex(color: number[]): string;
-/**
- * Apply unit conversion based on output unit and DPI
- */
-export declare function convertUnits(valueInPx: number, targetUnit: 'px' | 'cm' | 'in', dpi?: number): number;

package/lib/pdf-import/coordinate-transform.js

@@ -1,99 +0,0 @@
-/**
- * Transform PDF coordinates (bottom-left origin) to Polotno coordinates (top-left origin)
- */
-export function pdfToPolotnoY(pdfY, elementHeight, pageHeight) {
-    // PDF uses bottom-left origin, Polotno uses top-left
-    // PDFy is distance from bottom, we need distance from top
-    return pageHeight - pdfY - elementHeight;
-}
-/**
- * X coordinate remains the same between PDF and Polotno
- */
-export function pdfToPolotnoX(pdfX) {
-    return pdfX;
-}
-/**
- * Extract rotation angle from PDF transformation matrix
- * PDF transformation matrix is [a, b, c, d, e, f]
- * where rotation is encoded in a, b, c, d components
- */
-export function extractRotation(transform) {
-    const [a, b, c, d] = transform;
-    // Calculate rotation angle from matrix
-    // For a rotation matrix: a = cos(θ), b = sin(θ), c = -sin(θ), d = cos(θ)
-    const rotation = Math.atan2(b, a) * (180 / Math.PI);
-    return rotation;
-}
-/**
- * Extract scale from PDF transformation matrix
- */
-export function extractScale(transform) {
-    const [a, b, c, d] = transform;
-    // Scale is the magnitude of the transformation vectors
-    const scaleX = Math.sqrt(a * a + b * b);
-    const scaleY = Math.sqrt(c * c + d * d);
-    return { scaleX, scaleY };
-}
-/**
- * Extract position from PDF transformation matrix
- * Returns position in PDF coordinates (will need to be converted to Polotno)
- */
-export function extractPosition(transform) {
-    return {
-        x: transform[4],
-        y: transform[5],
-    };
-}
-/**
- * Calculate font size from PDF transformation matrix
- * Font size is encoded in the scale component of the matrix
- */
-export function calculateFontSize(transform) {
-    const { scaleY } = extractScale(transform);
-    return Math.abs(scaleY);
-}
-/**
- * Transform a complete bounding box from PDF to Polotno coordinates
- */
-export function transformBoundingBox(pdfX, pdfY, width, height, pageHeight) {
-    return {
-        x: pdfToPolotnoX(pdfX),
-        y: pdfToPolotnoY(pdfY, height, pageHeight),
-        width,
-        height,
-    };
-}
-/**
- * Convert PDF color array [r, g, b] (0-1 range) to hex color string
- */
-export function pdfColorToHex(color) {
-    if (!color || color.length < 3) {
-        return '#000000';
-    }
-    // PDF colors are in 0-1 range, convert to 0-255
-    const r = Math.round(color[0] * 255);
-    const g = Math.round(color[1] * 255);
-    const b = Math.round(color[2] * 255);
-    // Convert to hex
-    const hex = '#' + [r, g, b]
-        .map(x => x.toString(16).padStart(2, '0'))
-        .join('');
-    return hex;
-}
-/**
- * Apply unit conversion based on output unit and DPI
- */
-export function convertUnits(valueInPx, targetUnit, dpi = 72) {
-    if (targetUnit === 'px') {
-        return valueInPx;
-    }
-    // Convert pixels to points first (assuming 72 DPI as PDF standard)
-    const points = valueInPx;
-    if (targetUnit === 'in') {
-        return points / dpi;
-    }
-    if (targetUnit === 'cm') {
-        return (points / dpi) * 2.54;
-    }
-    return valueInPx;
-}

package/lib/pdf-import/element-builder.d.ts

@@ -1,21 +0,0 @@
-import type { TextBlock, ImageBlock, PDFImageObject, PDFImportOptions } from './types.js';
-/**
- * Build Polotno text element from text block
- */
-export declare function buildTextElement(block: TextBlock): any;
-/**
- * Build Polotno image element from image block
- */
-export declare function buildImageElement(imageBlock: ImageBlock): any;
-/**
- * Convert PDF image to data URL
- */
-export declare function imageToDataURL(buffer: Buffer, mimeType: string): Promise<string>;
-/**
- * Process PDF image and create image block
- */
-export declare function processImage(pdfImage: PDFImageObject, pageHeight: number, options: PDFImportOptions): Promise<ImageBlock | null>;
-/**
- * Process all images from a PDF page
- */
-export declare function processImages(pdfImages: PDFImageObject[], pageHeight: number, options: PDFImportOptions): Promise<any[]>;

package/lib/pdf-import/element-builder.js

@@ -1,163 +0,0 @@
-import { pdfToPolotnoX, pdfToPolotnoY, extractRotation } from './coordinate-transform.js';
-/**
- * Generate a random ID for Polotno elements
- */
-function randomId() {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < 10; i++) {
-        result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-}
-/**
- * Build Polotno text element from text block
- */
-export function buildTextElement(block) {
-    return {
-        type: 'text',
-        id: randomId(),
-        name: '',
-        x: block.x,
-        y: block.y,
-        width: block.width,
-        height: block.height,
-        rotation: block.rotation || 0,
-        // Text content
-        text: block.text,
-        // Font properties
-        fontSize: block.fontSize,
-        fontFamily: block.fontName,
-        fontWeight: block.fontWeight,
-        fontStyle: block.fontStyle,
-        // Color and styling
-        fill: block.color,
-        stroke: 'black',
-        strokeWidth: 0,
-        // Alignment
-        align: block.align || 'left',
-        verticalAlign: 'top',
-        // Text properties
-        lineHeight: 1.2,
-        letterSpacing: 0,
-        // Visibility
-        opacity: 1,
-        visible: true,
-        selectable: true,
-        draggable: true,
-        resizable: true,
-        contentEditable: true,
-        removable: true,
-        // Background (disabled by default)
-        backgroundEnabled: false,
-        // No effects by default
-        shadowEnabled: false,
-        blurEnabled: false,
-    };
-}
-/**
- * Build Polotno image element from image block
- */
-export function buildImageElement(imageBlock) {
-    return {
-        type: 'image',
-        id: randomId(),
-        name: '',
-        x: imageBlock.x,
-        y: imageBlock.y,
-        width: imageBlock.width,
-        height: imageBlock.height,
-        rotation: imageBlock.rotation || 0,
-        // Image source
-        src: imageBlock.src,
-        // Cropping (no crop by default)
-        cropX: 0,
-        cropY: 0,
-        cropWidth: 1,
-        cropHeight: 1,
-        // Transformations
-        flipX: false,
-        flipY: false,
-        // Border
-        borderColor: 'black',
-        borderSize: 0,
-        cornerRadius: 0,
-        // Visibility
-        opacity: 1,
-        visible: true,
-        selectable: true,
-        draggable: true,
-        resizable: true,
-        removable: true,
-        // No effects by default
-        shadowEnabled: false,
-        blurEnabled: false,
-        filters: {},
-    };
-}
-/**
- * Convert PDF image to data URL
- */
-export async function imageToDataURL(buffer, mimeType) {
-    const base64 = buffer.toString('base64');
-    return `data:${mimeType};base64,${base64}`;
-}
-/**
- * Process PDF image and create image block
- */
-export async function processImage(pdfImage, pageHeight, options) {
-    try {
-        // Extract components from transform matrix
-        // Transform matrix: [a, b, c, d, e, f] where:
-        // - a,d are scale X,Y (or combined with rotation)
-        // - b,c are rotation/skew
-        // - e,f are translation X,Y
-        const [a, b, c, d, e, f] = pdfImage.transform;
-        // Calculate dimensions from scale components
-        const scaleX = Math.sqrt(a * a + b * b);
-        const scaleY = Math.sqrt(c * c + d * d);
-        const width = Math.abs(scaleX);
-        const height = Math.abs(scaleY);
-        // Extract rotation
-        const rotation = extractRotation(pdfImage.transform);
-        // Extract position (e,f are the translation components)
-        const x = pdfToPolotnoX(e);
-        // Check if Y is flipped (negative scaleY means coordinate system is already top-left)
-        const isYFlipped = d < 0;
-        const y = isYFlipped
-            ? f // Already top-left origin, use directly
-            : pdfToPolotnoY(f, height, pageHeight); // Bottom-left origin, needs conversion
-        // Handle image data based on mode
-        let src;
-        if (options.imageMode === 'upload' && options.imageUploadFn) {
-            // Upload image and get URL
-            src = await options.imageUploadFn(pdfImage.buffer, pdfImage.mimeType);
-        }
-        else {
-            // Convert to data URL (default)
-            src = await imageToDataURL(pdfImage.buffer, pdfImage.mimeType);
-        }
-        return {
-            src,
-            x,
-            y,
-            width,
-            height,
-            rotation,
-        };
-    }
-    catch (error) {
-        console.warn('Failed to process image:', error);
-        return null;
-    }
-}
-/**
- * Process all images from a PDF page
- */
-export async function processImages(pdfImages, pageHeight, options) {
-    const imageBlocks = await Promise.all(pdfImages.map(img => processImage(img, pageHeight, options)));
-    // Filter out null results and build elements
-    return imageBlocks
-        .filter((block) => block !== null)
-        .map(block => buildImageElement(block));
-}