file2md 1.1.8 → 1.1.10

package/dist/utils/slide-renderer.js

@@ -5,30 +5,80 @@ import libre from 'libreoffice-convert';
 import { fromBuffer } from 'pdf2pic';
 import { promisify } from 'node:util';
 import { ParseError } from '../types/errors.js';
+import { LibreOfficeDetector } from './libreoffice-detector.js';
+import { LibreOfficeConverter } from './libreoffice-converter.js';
+import { PptxVisualParser } from './pptx-visual-parser.js';
+import { PuppeteerRenderer } from './puppeteer-renderer.js';
 // Promisify libreoffice-convert
 const convertAsync = promisify(libre.convert);
 export class SlideRenderer {
     outputDir;
+    converter;
     constructor(outputDir) {
         this.outputDir = outputDir;
+        this.converter = new LibreOfficeConverter();
     }
     /**
      * Convert PPTX buffer to individual slide images
      */
     async renderSlidesToImages(pptxBuffer, options = {}) {
-        const { quality = 90, density = 150, format = 'png', saveBase64 = false } = options;
+        const { quality = 90, density = 150, format = 'png', saveBase64 = false, useVisualLayouts = true, usePuppeteer = false, puppeteerOptions } = options;
         try {
             // Ensure output directory exists
             await fs.mkdir(this.outputDir, { recursive: true });
             console.log('Created slide output directory:', this.outputDir);
-            // Step 1: Convert PPTX to PDF using LibreOffice
-            console.log('Converting PPTX to PDF...');
+            // Step 1: Optionally parse visual layouts for enhanced rendering
+            let visualLayouts;
+            if (useVisualLayouts || usePuppeteer) {
+                try {
+                    console.log('Parsing visual layouts for enhanced rendering...');
+                    const visualParser = new PptxVisualParser();
+                    visualLayouts = await visualParser.parseVisualElements(pptxBuffer);
+                    console.log(`Extracted visual layouts for ${visualLayouts.length} slides`);
+                }
+                catch (visualError) {
+                    console.warn('Visual layout parsing failed, continuing with standard rendering:', visualError);
+                }
+            }
+            // Step 2: Try Puppeteer rendering first if requested and visual layouts are available
+            if (usePuppeteer && visualLayouts && visualLayouts.length > 0) {
+                try {
+                    console.log('Attempting Puppeteer browser-based rendering...');
+                    const puppeteerResult = await this.renderWithPuppeteer(visualLayouts, {
+                        ...puppeteerOptions,
+                        format: format === 'jpg' ? 'jpeg' : format,
+                        quality
+                    });
+                    if (puppeteerResult.slideImages.length > 0) {
+                        console.log(`Puppeteer rendering successful: ${puppeteerResult.slideImages.length} slides`);
+                        return {
+                            slideImages: puppeteerResult.slideImages,
+                            slideCount: puppeteerResult.slideCount,
+                            visualLayouts,
+                            metadata: {
+                                ...puppeteerResult.metadata,
+                                hasVisualLayouts: true
+                            }
+                        };
+                    }
+                }
+                catch (puppeteerError) {
+                    console.warn('Puppeteer rendering failed, falling back to LibreOffice:', puppeteerError);
+                }
+            }
+            // Step 3: Fallback to LibreOffice PDF rendering
+            console.log('Converting PPTX to PDF using LibreOffice...');
             const pdfBuffer = await this.convertPptxToPdf(pptxBuffer);
             console.log('PPTX to PDF conversion successful, PDF size:', pdfBuffer.length);
-            // Step 2: Convert PDF to individual slide images
+            // Step 3: Convert PDF to individual slide images
             console.log('Converting PDF to slide images...');
             const slideImages = await this.convertPdfToSlideImages(pdfBuffer, { quality, density, format, saveBase64 });
             console.log(`Generated ${slideImages.length} slide images`);
+            // Step 4: Enhance slides using visual layouts if available
+            if (visualLayouts && slideImages.length === visualLayouts.length) {
+                console.log('Enhancing slide images with visual layout information...');
+                await this.enhanceSlideImagesWithLayouts(slideImages, visualLayouts, { quality, density, format });
+            }
             // Verify images were actually created
             for (const slide of slideImages) {
                 const exists = await fs.access(slide.savedPath).then(() => true).catch(() => false);
@@ -37,10 +87,12 @@ export class SlideRenderer {
             return {
                 slideImages,
                 slideCount: slideImages.length,
+                visualLayouts,
                 metadata: {
                     format,
                     quality,
-                    density
+                    density,
+                    hasVisualLayouts: visualLayouts !== undefined
                 }
             };
         }
@@ -51,24 +103,60 @@ export class SlideRenderer {
         }
     }
     /**
-     * Convert PPTX buffer to PDF buffer using multiple methods
+     * Convert PPTX buffer to PDF buffer using enhanced LibreOffice converter
      */
     async convertPptxToPdf(pptxBuffer) {
-        // Try LibreOffice first
+        // Check LibreOffice installation first
+        const detector = LibreOfficeDetector.getInstance();
+        const libreOfficeInfo = await detector.checkLibreOfficeInstallation();
+        if (!libreOfficeInfo.installed) {
+            console.error('LibreOffice is not installed on this system.');
+            console.error('Error:', libreOfficeInfo.error);
+            console.log('\n' + detector.getInstallationInstructions());
+            console.log('Download URL:', detector.getDownloadUrl());
+            // Continue with alternative method
+            console.log('Attempting alternative slide screenshot generation...');
+            return await this.createAlternativeSlideImages(pptxBuffer);
+        }
+        // Check version compatibility
+        if (!detector.isVersionSupported(libreOfficeInfo.version)) {
+            console.warn(`LibreOffice version ${libreOfficeInfo.version} is below the recommended version 7.0`);
+        }
+        console.log(`LibreOffice detected: ${libreOfficeInfo.path} (version ${libreOfficeInfo.version})`);
+        // Try enhanced LibreOffice conversion with progress tracking
         try {
-            console.log('Trying LibreOffice conversion...');
-            const pdfBuffer = await convertAsync(pptxBuffer, '.pdf', undefined);
+            console.log('Starting enhanced LibreOffice conversion...');
+            const pdfBuffer = await this.converter.convertWithProgress(pptxBuffer, {
+                quality: 'maximum',
+                timeout: 60000,
+                additionalArgs: ['--nofirststartwizard']
+            }, (progress) => {
+                console.log(`Conversion progress: ${progress.stage} - ${progress.message}`);
+            });
             if (pdfBuffer && pdfBuffer.length > 0) {
-                console.log('LibreOffice conversion successful, PDF size:', pdfBuffer.length);
+                console.log('Enhanced LibreOffice conversion successful, PDF size:', pdfBuffer.length);
                 return pdfBuffer;
             }
         }
         catch (libreOfficeError) {
             const message = libreOfficeError instanceof Error ? libreOfficeError.message : 'Unknown error';
-            console.log('LibreOffice conversion failed:', message);
+            console.error('Enhanced LibreOffice conversion failed:', message);
+            // Fallback to simple conversion method
+            try {
+                console.log('Trying fallback LibreOffice conversion...');
+                const pdfBuffer = await convertAsync(pptxBuffer, '.pdf', undefined);
+                if (pdfBuffer && pdfBuffer.length > 0) {
+                    console.log('Fallback LibreOffice conversion successful, PDF size:', pdfBuffer.length);
+                    return pdfBuffer;
+                }
+            }
+            catch (fallbackError) {
+                const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : 'Unknown error';
+                console.error('Fallback LibreOffice conversion also failed:', fallbackMessage);
+            }
         }
-        // LibreOffice failed, try alternative approach
-        console.log('Attempting alternative slide screenshot generation...');
+        // All LibreOffice methods failed, try alternative approach
+        console.log('All LibreOffice methods failed, falling back to alternative slide screenshot generation...');
         return await this.createAlternativeSlideImages(pptxBuffer);
     }
     /**
@@ -146,7 +234,7 @@ export class SlideRenderer {
     }
     generatedSlideImages = [];
     /**
-     * Render a single slide to image using canvas
+     * Render a single slide to image using canvas with multi-language font support
      */
     async renderSlideToImage(slideData, slideNumber, zip) {
         try {
@@ -163,23 +251,31 @@ export class SlideRenderer {
             const height = 1080;
             const canvas = Canvas.createCanvas(width, height);
             const ctx = canvas.getContext('2d');
+            // Register fonts for international character support
+            await this.registerFontsForCanvas(Canvas);
             // Set background
             ctx.fillStyle = '#ffffff';
             ctx.fillRect(0, 0, width, height);
-            // Add slide number
+            // Add slide number with multi-language font
             ctx.fillStyle = '#333333';
-            ctx.font = '48px Arial';
+            ctx.font = this.getUniversalFont(48);
             ctx.textAlign = 'center';
             ctx.fillText(`Slide ${slideNumber}`, width / 2, 100);
             // Extract and render text content
             const textContent = this.extractSlideText(slideData);
             if (textContent.length > 0) {
-                ctx.font = '32px Arial';
+                ctx.font = this.getUniversalFont(32);
                 ctx.textAlign = 'left';
                 let yPos = 200;
                 for (const text of textContent.slice(0, 20)) { // Limit to 20 lines
-                    ctx.fillText(text.substring(0, 80), 100, yPos); // Limit line length
-                    yPos += 50;
+                    // Handle long text with proper wrapping
+                    const wrappedLines = this.wrapText(ctx, text, width - 200); // Leave margins
+                    for (const line of wrappedLines.slice(0, 2)) { // Max 2 lines per text element
+                        ctx.fillText(line, 100, yPos);
+                        yPos += 50;
+                        if (yPos > height - 100)
+                            break;
+                    }
                     if (yPos > height - 100)
                         break;
                 }
@@ -195,17 +291,174 @@ export class SlideRenderer {
             return await this.createTextBasedSlideImage(slideData, slideNumber);
         }
     }
+    /**
+     * Register system fonts and fallback fonts for international character support
+     */
+    async registerFontsForCanvas(Canvas) {
+        try {
+            // Try to register common system fonts that support international characters
+            const fontPaths = [
+                // Windows fonts
+                'C:\\Windows\\Fonts\\arial.ttf',
+                'C:\\Windows\\Fonts\\SimSun.ttc', // Chinese (Simplified)
+                'C:\\Windows\\Fonts\\mingliu.ttc', // Chinese (Traditional)
+                'C:\\Windows\\Fonts\\malgun.ttf', // Korean
+                'C:\\Windows\\Fonts\\meiryo.ttc', // Japanese
+                'C:\\Windows\\Fonts\\NotoSansCJK-Regular.ttc', // Noto CJK
+                // macOS fonts
+                '/System/Library/Fonts/Arial.ttf',
+                '/System/Library/Fonts/PingFang.ttc', // Chinese
+                '/System/Library/Fonts/AppleGothic.ttf', // Korean
+                '/System/Library/Fonts/Hiragino Sans GB.ttc', // Japanese/Chinese
+                // Linux fonts
+                '/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf',
+                '/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc',
+                '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf'
+            ];
+            const fs = await import('fs/promises');
+            for (const fontPath of fontPaths) {
+                try {
+                    await fs.access(fontPath);
+                    Canvas.registerFont(fontPath, {
+                        family: this.getFontFamily(fontPath)
+                    });
+                    console.log(`Registered font: ${fontPath}`);
+                }
+                catch {
+                    // Font file doesn't exist, skip silently
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Font registration failed:', error);
+            // Continue without custom fonts - will use Canvas defaults
+        }
+    }
+    /**
+     * Get font family name from font path
+     */
+    getFontFamily(fontPath) {
+        const filename = fontPath.split(/[/\\]/).pop() || '';
+        if (filename.includes('SimSun') || filename.includes('PingFang'))
+            return 'SimSun';
+        if (filename.includes('malgun') || filename.includes('AppleGothic'))
+            return 'Malgun Gothic';
+        if (filename.includes('meiryo') || filename.includes('Hiragino'))
+            return 'Meiryo';
+        if (filename.includes('Noto'))
+            return 'Noto Sans CJK';
+        if (filename.includes('Liberation'))
+            return 'Liberation Sans';
+        if (filename.includes('DejaVu'))
+            return 'DejaVu Sans';
+        return 'Arial'; // Default fallback
+    }
+    /**
+     * Get universal font string with fallbacks for international characters
+     */
+    getUniversalFont(size) {
+        // Use a comprehensive font stack that covers most international characters
+        return `${size}px "Noto Sans CJK", "SimSun", "Malgun Gothic", "Meiryo", "Liberation Sans", "DejaVu Sans", "Arial Unicode MS", Arial, sans-serif`;
+    }
+    /**
+     * Wrap text to fit within specified width
+     */
+    wrapText(ctx, text, maxWidth) {
+        const words = text.split(' ');
+        const lines = [];
+        let currentLine = '';
+        for (const word of words) {
+            const testLine = currentLine ? `${currentLine} ${word}` : word;
+            const metrics = ctx.measureText(testLine);
+            if (metrics.width > maxWidth && currentLine) {
+                lines.push(currentLine);
+                currentLine = word;
+            }
+            else {
+                currentLine = testLine;
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines;
+    }
     /**
      * Create a text-based slide image when canvas is not available
      */
     async createTextBasedSlideImage(slideData, slideNumber) {
-        // Create a simple text-based representation
-        // This is a fallback when canvas is not available
-        const textContent = this.extractSlideText(slideData);
-        const slideText = `SLIDE ${slideNumber}\n\n${textContent.join('\n')}`;
-        // Create a simple PNG with text (this is a basic fallback)
-        // In a real implementation, you might use a simpler image generation library
-        return Buffer.from(`Slide ${slideNumber} Content:\n${slideText}`);
+        try {
+            // Try to use a simple image generation approach
+            const textContent = this.extractSlideText(slideData);
+            // Create a minimal SVG that can be converted to PNG
+            const svgContent = this.createSVGSlideImage(slideNumber, textContent);
+            // Try to convert SVG to PNG buffer
+            return await this.convertSVGToPNG(svgContent);
+        }
+        catch (error) {
+            console.warn('SVG fallback failed:', error);
+            // Ultimate fallback - return a simple text buffer
+            const textContent = this.extractSlideText(slideData);
+            const slideText = `SLIDE ${slideNumber}\n\n${textContent.join('\n')}`;
+            return Buffer.from(`Slide ${slideNumber} Content:\n${slideText}`);
+        }
+    }
+    /**
+     * Create SVG representation of slide content
+     */
+    createSVGSlideImage(slideNumber, textContent) {
+        const width = 1920;
+        const height = 1080;
+        let svgContent = `<?xml version="1.0" encoding="UTF-8"?>
+<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+  <!-- Background -->
+  <rect width="${width}" height="${height}" fill="white" stroke="#cccccc" stroke-width="4"/>
+  
+  <!-- Slide Number -->
+  <text x="${width / 2}" y="100" text-anchor="middle" font-family="Arial, sans-serif" font-size="48" fill="#333333">Slide ${slideNumber}</text>
+  
+  <!-- Content -->`;
+        let yPos = 200;
+        for (const text of textContent.slice(0, 15)) { // Limit to 15 lines
+            if (yPos > height - 100)
+                break;
+            // Escape HTML entities for SVG
+            const escapedText = text
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .substring(0, 80); // Limit line length
+            svgContent += `
+  <text x="100" y="${yPos}" font-family="Arial, sans-serif" font-size="32" fill="#333333">${escapedText}</text>`;
+            yPos += 50;
+        }
+        svgContent += `
+</svg>`;
+        return svgContent;
+    }
+    /**
+     * Convert SVG to PNG buffer
+     */
+    async convertSVGToPNG(svgContent) {
+        try {
+            // Try to use Canvas to convert SVG to PNG
+            const Canvas = await import('canvas');
+            const { createCanvas, loadImage } = Canvas;
+            // Convert SVG string to data URL
+            const svgDataUrl = `data:image/svg+xml;base64,${Buffer.from(svgContent).toString('base64')}`;
+            const canvas = createCanvas(1920, 1080);
+            const ctx = canvas.getContext('2d');
+            // Load the SVG as an image
+            const img = await loadImage(svgDataUrl);
+            ctx.drawImage(img, 0, 0);
+            return canvas.toBuffer('image/png');
+        }
+        catch (error) {
+            console.warn('SVG to PNG conversion failed:', error);
+            // Return simple placeholder buffer
+            throw error;
+        }
     }
     /**
      * Extract text content from slide XML data
@@ -258,7 +511,7 @@ export class SlideRenderer {
         return Buffer.from(placeholderText);
     }
     /**
-     * Convert PDF buffer to individual slide images using pdf2pic or return pre-generated images
+     * Convert PDF buffer to individual slide images with optimization
      */
     async convertPdfToSlideImages(pdfBuffer, options) {
         try {
@@ -267,24 +520,21 @@ export class SlideRenderer {
                 console.log('Using pre-generated slide images from alternative method');
                 return this.generatedSlideImages;
             }
-            // Standard PDF to image conversion using pdf2pic
+            // Standard PDF to image conversion using pdf2pic with optimization
             await fs.mkdir(this.outputDir, { recursive: true });
             console.log('PDF to images: Output directory created:', this.outputDir);
-            // Configure pdf2pic
+            // Optimize settings based on quality
+            const optimizedOptions = this.optimizePdfToImageSettings(options);
+            console.log('Optimized PDF2PIC settings:', optimizedOptions);
+            // Configure pdf2pic with optimized settings
             const convert = fromBuffer(pdfBuffer, {
-                density: options.density,
+                density: optimizedOptions.density,
                 saveFilename: 'slide',
                 savePath: this.outputDir,
                 format: options.format,
-                width: undefined, // Let pdf2pic calculate based on density
-                height: undefined,
-                quality: options.quality
-            });
-            console.log('PDF2PIC configuration:', {
-                density: options.density,
-                format: options.format,
-                quality: options.quality,
-                outputDir: this.outputDir
+                width: optimizedOptions.width,
+                height: optimizedOptions.height,
+                quality: optimizedOptions.quality
             });
             // Get total number of pages first
             const storeAsImage = convert.bulk(-1, true);
@@ -297,22 +547,39 @@ export class SlideRenderer {
                 const filename = `slide-${slideNumber.toString().padStart(3, '0')}.${options.format}`;
                 const savedPath = path.join(this.outputDir, filename);
                 console.log(`Processing slide ${slideNumber}, expected file: ${filename}`);
-                // Save the image file
-                const imageBuffer = result.buffer;
-                if (imageBuffer) {
-                    await fs.writeFile(savedPath, imageBuffer);
-                    console.log(`Saved slide image: ${savedPath} (${imageBuffer.length} bytes)`);
-                    slideImages.push({
-                        originalPath: `slide${slideNumber}`, // Virtual path for consistency
-                        savedPath: savedPath,
-                        size: imageBuffer.length,
-                        format: options.format
-                    });
+                // Save the image file with error handling
+                try {
+                    const imageBuffer = result.buffer;
+                    if (imageBuffer && imageBuffer.length > 0) {
+                        await fs.writeFile(savedPath, imageBuffer);
+                        // Verify file was written correctly
+                        const stats = await fs.stat(savedPath);
+                        if (stats.size > 0) {
+                            console.log(`Saved slide image: ${savedPath} (${stats.size} bytes)`);
+                            slideImages.push({
+                                originalPath: `slide${slideNumber}`,
+                                savedPath: savedPath,
+                                size: stats.size,
+                                format: options.format
+                            });
+                        }
+                        else {
+                            console.warn(`Slide ${slideNumber} file is empty after writing`);
+                        }
+                    }
+                    else {
+                        console.warn(`No buffer found for slide ${slideNumber}`);
+                    }
                 }
-                else {
-                    console.warn(`No buffer found for slide ${slideNumber}`);
+                catch (slideError) {
+                    const slideMessage = slideError instanceof Error ? slideError.message : 'Unknown error';
+                    console.warn(`Failed to process slide ${slideNumber}: ${slideMessage}`);
+                    // Continue processing other slides
                 }
             }
+            if (slideImages.length === 0) {
+                throw new Error('No slide images were successfully created');
+            }
             console.log(`Successfully created ${slideImages.length} slide images`);
             return slideImages;
         }
@@ -322,6 +589,53 @@ export class SlideRenderer {
             throw new ParseError('SlideRenderer', `PDF to images conversion failed: ${message}`, error);
         }
     }
+    /**
+     * Optimize PDF to image conversion settings based on quality requirements
+     */
+    optimizePdfToImageSettings(options) {
+        // Standard slide dimensions (16:9 aspect ratio)
+        const baseWidth = 1920;
+        const baseHeight = 1080;
+        // Adjust settings based on quality
+        let optimizedDensity = options.density;
+        let optimizedQuality = options.quality;
+        let width = baseWidth;
+        let height = baseHeight;
+        if (options.quality >= 95) {
+            // Ultra-high quality
+            optimizedDensity = Math.max(options.density, 300);
+            optimizedQuality = 100;
+            width = 2560;
+            height = 1440;
+        }
+        else if (options.quality >= 85) {
+            // High quality
+            optimizedDensity = Math.max(options.density, 200);
+            optimizedQuality = Math.max(options.quality, 90);
+            width = 1920;
+            height = 1080;
+        }
+        else if (options.quality >= 70) {
+            // Medium quality
+            optimizedDensity = Math.max(options.density, 150);
+            optimizedQuality = Math.max(options.quality, 80);
+            width = 1600;
+            height = 900;
+        }
+        else {
+            // Lower quality for faster processing
+            optimizedDensity = Math.max(options.density, 100);
+            optimizedQuality = options.quality;
+            width = 1280;
+            height = 720;
+        }
+        return {
+            density: optimizedDensity,
+            quality: optimizedQuality,
+            width,
+            height
+        };
+    }
     /**
      * Generate markdown with slide images
      */
@@ -341,6 +655,94 @@ export class SlideRenderer {
         }
         return markdown.trim();
     }
+    /**
+     * Enhance slide images using visual layout information
+     */
+    async enhanceSlideImagesWithLayouts(slideImages, visualLayouts, options) {
+        try {
+            // Try to import Canvas for enhanced rendering
+            let Canvas;
+            try {
+                Canvas = await import('canvas');
+            }
+            catch {
+                console.log('Canvas module not available for slide enhancement');
+                return;
+            }
+            for (let i = 0; i < slideImages.length && i < visualLayouts.length; i++) {
+                const slideImage = slideImages[i];
+                const layout = visualLayouts[i];
+                try {
+                    // Read existing slide image
+                    const originalImageBuffer = await fs.readFile(slideImage.savedPath);
+                    // Create canvas from original image
+                    const originalImage = await Canvas.loadImage(originalImageBuffer);
+                    const canvas = Canvas.createCanvas(originalImage.width, originalImage.height);
+                    const ctx = canvas.getContext('2d');
+                    // Draw original image as base
+                    ctx.drawImage(originalImage, 0, 0);
+                    // Overlay additional visual elements if needed
+                    await this.addVisualEnhancements(ctx, layout, {
+                        width: originalImage.width,
+                        height: originalImage.height,
+                        slideNumber: i + 1
+                    });
+                    // Save enhanced image (optional - only if we made changes)
+                    const enhancedBuffer = canvas.toBuffer(`image/${options.format}`);
+                    // Only replace if the enhancement actually improved the image
+                    if (enhancedBuffer.length > 0) {
+                        console.log(`Enhanced slide ${i + 1} with visual layout information`);
+                        // For now, we'll keep the original to avoid overwriting working images
+                        // In the future, this could replace the original with the enhanced version
+                    }
+                }
+                catch (slideError) {
+                    console.warn(`Failed to enhance slide ${i + 1}:`, slideError);
+                    // Continue with other slides
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Slide enhancement failed:', error);
+            // Enhancement is optional, so we don't throw errors
+        }
+    }
+    /**
+     * Add visual enhancements based on layout information
+     */
+    async addVisualEnhancements(ctx, layout, dimensions) {
+        try {
+            // Register fonts for international character support
+            const Canvas = await import('canvas');
+            await this.registerFontsForCanvas(Canvas);
+            // Add subtle overlay indicators for different element types
+            const textElements = layout.elements.filter(e => e.type === 'text');
+            const imageElements = layout.elements.filter(e => e.type === 'image');
+            const chartElements = layout.elements.filter(e => e.type === 'chart');
+            // Add corner annotations for element counts (very subtle)
+            if (textElements.length > 0 || imageElements.length > 0 || chartElements.length > 0) {
+                ctx.save();
+                ctx.fillStyle = 'rgba(0, 0, 0, 0.1)';
+                ctx.font = this.getUniversalFont(12);
+                let annotationY = dimensions.height - 30;
+                if (textElements.length > 0) {
+                    ctx.fillText(`📝 ${textElements.length}`, 10, annotationY);
+                    annotationY -= 15;
+                }
+                if (imageElements.length > 0) {
+                    ctx.fillText(`🖼️ ${imageElements.length}`, 10, annotationY);
+                    annotationY -= 15;
+                }
+                if (chartElements.length > 0) {
+                    ctx.fillText(`📊 ${chartElements.length}`, 10, annotationY);
+                }
+                ctx.restore();
+            }
+        }
+        catch (error) {
+            console.warn('Failed to add visual enhancements:', error);
+        }
+    }
     /**
      * Clean up generated image files
      */
@@ -357,6 +759,24 @@ export class SlideRenderer {
             // Ignore cleanup errors
         }
     }
+    /**
+     * Render slides using Puppeteer browser-based rendering
+     */
+    async renderWithPuppeteer(visualLayouts, options = {}) {
+        const puppeteerRenderer = new PuppeteerRenderer(this.outputDir);
+        try {
+            const result = await puppeteerRenderer.renderSlidesFromLayouts(visualLayouts, options);
+            return {
+                slideImages: [...result.slideImages],
+                slideCount: result.slideCount,
+                metadata: result.metadata
+            };
+        }
+        finally {
+            // Always cleanup Puppeteer resources
+            await puppeteerRenderer.cleanup();
+        }
+    }
     /**
      * Check if LibreOffice is available on the system
      */
@@ -371,5 +791,11 @@ export class SlideRenderer {
             return false;
         }
     }
+    /**
+     * Check if Puppeteer is available on the system
+     */
+    static async checkPuppeteerAvailability() {
+        return await PuppeteerRenderer.isAvailable();
+    }
 }
 //# sourceMappingURL=slide-renderer.js.map