@fin.cx/einvoice 5.0.2

package/dist_ts/formats/pdf/extractors/text.extractor.js

@@ -0,0 +1,151 @@
+import { BaseXMLExtractor } from './base.extractor.js';
+/**
+ * Text-based XML extractor for PDF documents
+ * Extracts XML by searching for XML patterns in the PDF text
+ * Used as a fallback when other extraction methods fail
+ */
+export class TextXMLExtractor extends BaseXMLExtractor {
+    constructor() {
+        super(...arguments);
+        // Maximum chunk size to process at once (4MB)
+        this.CHUNK_SIZE = 4 * 1024 * 1024;
+        // Maximum number of chunks to check (effective 20MB search limit)
+        this.MAX_CHUNKS = 5;
+        // Common XML patterns to look for
+        this.XML_PATTERNS = [
+            '<?xml',
+            '<CrossIndustryInvoice',
+            '<CrossIndustryDocument',
+            '<Invoice',
+            '<CreditNote',
+            '<rsm:CrossIndustryInvoice',
+            '<rsm:CrossIndustryDocument',
+            '<ram:CrossIndustryDocument',
+            '<ubl:Invoice',
+            '<ubl:CreditNote',
+            '<FatturaElettronica'
+        ];
+    }
+    /**
+     * Extract XML from a PDF buffer by searching for XML patterns in the text
+     * Uses a chunked approach to handle large files efficiently
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    async extractXml(pdfBuffer) {
+        try {
+            console.log('Attempting text-based XML extraction from PDF...');
+            // Convert Buffer to Uint8Array if needed
+            const buffer = Buffer.isBuffer(pdfBuffer) ? new Uint8Array(pdfBuffer) : pdfBuffer;
+            // Try extracting XML using the chunked approach
+            return this.extractXmlFromBufferChunked(buffer);
+        }
+        catch (error) {
+            console.error('Error in text-based extraction:', error);
+            return null;
+        }
+    }
+    /**
+     * Extract XML from buffer using a chunked approach
+     * This helps avoid memory issues with large PDFs
+     * @param buffer Buffer to search in
+     * @returns XML content or null if not found
+     */
+    extractXmlFromBufferChunked(buffer) {
+        // Process the PDF in chunks
+        for (let chunkIndex = 0; chunkIndex < this.MAX_CHUNKS; chunkIndex++) {
+            const startPos = chunkIndex * this.CHUNK_SIZE;
+            if (startPos >= buffer.length)
+                break;
+            const endPos = Math.min(startPos + this.CHUNK_SIZE, buffer.length);
+            const chunk = buffer.slice(startPos, endPos);
+            // Try to extract XML from this chunk
+            const chunkResult = this.processChunk(chunk, startPos);
+            if (chunkResult) {
+                return chunkResult;
+            }
+        }
+        console.warn('No valid XML found in any chunk of the PDF');
+        return null;
+    }
+    /**
+     * Process a single chunk of the PDF buffer
+     * @param chunk Chunk buffer to process
+     * @param chunkOffset Offset position of the chunk in the original buffer
+     * @returns XML content or null if not found
+     */
+    processChunk(chunk, chunkOffset) {
+        try {
+            // First try UTF-8 encoding for this chunk
+            const utf8String = this.decodeBufferToString(chunk, 'utf-8');
+            let xmlContent = this.searchForXmlInString(utf8String);
+            if (xmlContent) {
+                console.log(`Found XML content in chunk at offset ${chunkOffset} using UTF-8 encoding`);
+                return xmlContent;
+            }
+            // If UTF-8 fails, try Latin-1 (ISO-8859-1) which can handle binary better
+            const latin1String = this.decodeBufferToString(chunk, 'latin1');
+            xmlContent = this.searchForXmlInString(latin1String);
+            if (xmlContent) {
+                console.log(`Found XML content in chunk at offset ${chunkOffset} using Latin-1 encoding`);
+                return xmlContent;
+            }
+            // No XML found in this chunk
+            return null;
+        }
+        catch (error) {
+            console.warn(`Error processing chunk at offset ${chunkOffset}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Safely decode a buffer to string using the specified encoding
+     * @param buffer Buffer to decode
+     * @param encoding Encoding to use ('utf-8' or 'latin1')
+     * @returns Decoded string
+     */
+    decodeBufferToString(buffer, encoding) {
+        try {
+            if (encoding === 'utf-8') {
+                return new TextDecoder('utf-8', { fatal: false }).decode(buffer);
+            }
+            else {
+                // For Latin-1 we can use a direct mapping (bytes 0-255 map directly to code points 0-255)
+                // This is more reliable for binary data than TextDecoder for legacy encodings
+                return Array.from(buffer)
+                    .map(byte => String.fromCharCode(byte))
+                    .join('');
+            }
+        }
+        catch (error) {
+            console.warn(`Error decoding buffer using ${encoding}:`, error);
+            // Return empty string on error to allow processing to continue
+            return '';
+        }
+    }
+    /**
+     * Search for XML patterns in a string
+     * @param content String to search in
+     * @returns XML content or null if not found
+     */
+    searchForXmlInString(content) {
+        if (!content)
+            return null;
+        // Search for each XML pattern
+        for (const pattern of this.XML_PATTERNS) {
+            const patternIndex = content.indexOf(pattern);
+            if (patternIndex !== -1) {
+                console.log(`Found XML pattern "${pattern}" at position ${patternIndex}`);
+                // Try to extract the XML content starting from the pattern position
+                const xmlContent = this.extractXmlFromString(content, patternIndex);
+                // Validate the extracted content
+                if (xmlContent && this.isValidXml(xmlContent)) {
+                    console.log('Successfully extracted and validated XML from text');
+                    return xmlContent;
+                }
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/formats/pdf/pdf.embedder.d.ts

@@ -0,0 +1,69 @@
+import type { IPdf } from '../../interfaces/common.js';
+/**
+ * Error types for PDF embedding operations
+ */
+export declare enum PDFEmbedError {
+    LOAD_ERROR = "PDF loading failed",
+    EMBED_ERROR = "XML embedding failed",
+    SAVE_ERROR = "PDF saving failed",
+    INVALID_INPUT = "Invalid input parameters"
+}
+/**
+ * Result of a PDF embedding operation
+ */
+export interface PDFEmbedResult {
+    success: boolean;
+    data?: Uint8Array;
+    pdf?: IPdf;
+    error?: {
+        type: PDFEmbedError;
+        message: string;
+        originalError?: Error;
+    };
+}
+/**
+ * Class for embedding XML into PDF files
+ * Provides robust error handling and support for different PDF formats
+ */
+export declare class PDFEmbedder {
+    /**
+     * Embeds XML into a PDF
+     * @param pdfBuffer PDF buffer
+     * @param xmlContent XML content to embed
+     * @param filename Filename for the embedded XML
+     * @param description Description for the embedded XML
+     * @returns Result with either modified PDF buffer or error information
+     */
+    embedXml(pdfBuffer: Uint8Array | Buffer, xmlContent: string, filename?: string, description?: string): Promise<PDFEmbedResult>;
+    /**
+     * Creates an IPdf object with embedded XML
+     * @param pdfBuffer PDF buffer
+     * @param xmlContent XML content to embed
+     * @param filename Filename for the embedded XML
+     * @param description Description for the embedded XML
+     * @param pdfName Name for the PDF
+     * @param pdfId ID for the PDF
+     * @returns Result with either IPdf object or error information
+     */
+    createPdfWithXml(pdfBuffer: Uint8Array | Buffer, xmlContent: string, filename?: string, description?: string, pdfName?: string, pdfId?: string): Promise<PDFEmbedResult>;
+    /**
+     * Ensures the filename is normalized according to PDF/A requirements
+     * @param filename Filename to normalize
+     * @returns Normalized filename
+     */
+    private normalizeFilename;
+    /**
+     * Tries to detect the format of the XML content
+     * @param xmlContent XML content
+     * @returns Format string or undefined
+     */
+    private detectPdfFormat;
+    /**
+     * Creates an error result object
+     * @param type Error type
+     * @param message Error message
+     * @param originalError Original error object
+     * @returns Error result
+     */
+    private createErrorResult;
+}

package/dist_ts/formats/pdf/pdf.embedder.js

@@ -0,0 +1,183 @@
+import { PDFDocument, AFRelationship } from '../../plugins.js';
+/**
+ * Error types for PDF embedding operations
+ */
+export var PDFEmbedError;
+(function (PDFEmbedError) {
+    PDFEmbedError["LOAD_ERROR"] = "PDF loading failed";
+    PDFEmbedError["EMBED_ERROR"] = "XML embedding failed";
+    PDFEmbedError["SAVE_ERROR"] = "PDF saving failed";
+    PDFEmbedError["INVALID_INPUT"] = "Invalid input parameters";
+})(PDFEmbedError || (PDFEmbedError = {}));
+/**
+ * Class for embedding XML into PDF files
+ * Provides robust error handling and support for different PDF formats
+ */
+export class PDFEmbedder {
+    /**
+     * Embeds XML into a PDF
+     * @param pdfBuffer PDF buffer
+     * @param xmlContent XML content to embed
+     * @param filename Filename for the embedded XML
+     * @param description Description for the embedded XML
+     * @returns Result with either modified PDF buffer or error information
+     */
+    async embedXml(pdfBuffer, xmlContent, filename = 'invoice.xml', description = 'XML Invoice') {
+        try {
+            // Validate inputs
+            if (!pdfBuffer || pdfBuffer.length === 0) {
+                return this.createErrorResult(PDFEmbedError.INVALID_INPUT, 'PDF buffer is empty or undefined');
+            }
+            if (!xmlContent) {
+                return this.createErrorResult(PDFEmbedError.INVALID_INPUT, 'XML content is empty or undefined');
+            }
+            // Ensure buffer is Uint8Array
+            const pdfBufferArray = Buffer.isBuffer(pdfBuffer) ? new Uint8Array(pdfBuffer) : pdfBuffer;
+            // Load the PDF
+            let pdfDoc;
+            try {
+                pdfDoc = await PDFDocument.load(pdfBufferArray, {
+                    ignoreEncryption: true, // Try to load encrypted PDFs
+                    updateMetadata: false // Don't automatically update metadata
+                });
+            }
+            catch (error) {
+                return this.createErrorResult(PDFEmbedError.LOAD_ERROR, `Failed to load PDF: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+            }
+            // Normalize filename (lowercase with XML extension)
+            filename = this.normalizeFilename(filename);
+            // Convert the XML string to a Uint8Array
+            const xmlBuffer = new TextEncoder().encode(xmlContent);
+            try {
+                // Use pdf-lib's .attach() to embed the XML
+                pdfDoc.attach(xmlBuffer, filename, {
+                    mimeType: 'text/xml',
+                    description: description,
+                    creationDate: new Date(),
+                    modificationDate: new Date(),
+                    afRelationship: AFRelationship.Alternative,
+                });
+            }
+            catch (error) {
+                return this.createErrorResult(PDFEmbedError.EMBED_ERROR, `Failed to embed XML: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+            }
+            // Save the modified PDF
+            let modifiedPdfBytes;
+            try {
+                modifiedPdfBytes = await pdfDoc.save({
+                    addDefaultPage: false, // Don't add a page if the document is empty
+                    useObjectStreams: false, // Better compatibility with older PDF readers
+                    updateFieldAppearances: false // Don't update form fields
+                });
+            }
+            catch (error) {
+                return this.createErrorResult(PDFEmbedError.SAVE_ERROR, `Failed to save modified PDF: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+            }
+            return {
+                success: true,
+                data: modifiedPdfBytes
+            };
+        }
+        catch (error) {
+            // Catch any uncaught errors
+            return this.createErrorResult(PDFEmbedError.EMBED_ERROR, `Unexpected error during XML embedding: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Creates an IPdf object with embedded XML
+     * @param pdfBuffer PDF buffer
+     * @param xmlContent XML content to embed
+     * @param filename Filename for the embedded XML
+     * @param description Description for the embedded XML
+     * @param pdfName Name for the PDF
+     * @param pdfId ID for the PDF
+     * @returns Result with either IPdf object or error information
+     */
+    async createPdfWithXml(pdfBuffer, xmlContent, filename = 'invoice.xml', description = 'XML Invoice', pdfName = 'invoice.pdf', pdfId = `invoice-${Date.now()}`) {
+        // Embed XML into PDF
+        const embedResult = await this.embedXml(pdfBuffer, xmlContent, filename, description);
+        // If embedding failed, return the error
+        if (!embedResult.success || !embedResult.data) {
+            return embedResult;
+        }
+        // Create IPdf object
+        const pdfObject = {
+            name: pdfName,
+            id: pdfId,
+            metadata: {
+                textExtraction: '',
+                format: this.detectPdfFormat(xmlContent),
+                embeddedXml: {
+                    filename: filename,
+                    description: description
+                }
+            },
+            buffer: embedResult.data
+        };
+        return {
+            success: true,
+            pdf: pdfObject
+        };
+    }
+    /**
+     * Ensures the filename is normalized according to PDF/A requirements
+     * @param filename Filename to normalize
+     * @returns Normalized filename
+     */
+    normalizeFilename(filename) {
+        // Convert to lowercase
+        let normalized = filename.toLowerCase();
+        // Ensure it has .xml extension
+        if (!normalized.endsWith('.xml')) {
+            normalized = normalized.replace(/\.[^/.]+$/, '') + '.xml';
+        }
+        // Replace invalid characters
+        normalized = normalized.replace(/[^a-z0-9_.-]/g, '_');
+        return normalized;
+    }
+    /**
+     * Tries to detect the format of the XML content
+     * @param xmlContent XML content
+     * @returns Format string or undefined
+     */
+    detectPdfFormat(xmlContent) {
+        if (xmlContent.includes('factur-x.eu') || xmlContent.includes('factur-x.xml')) {
+            return 'factur-x';
+        }
+        else if (xmlContent.includes('zugferd') || xmlContent.includes('ZUGFeRD')) {
+            return 'zugferd';
+        }
+        else if (xmlContent.includes('xrechnung')) {
+            return 'xrechnung';
+        }
+        else if (xmlContent.includes('<Invoice') || xmlContent.includes('<CreditNote')) {
+            return 'ubl';
+        }
+        else if (xmlContent.includes('FatturaElettronica')) {
+            return 'fatturapa';
+        }
+        return undefined;
+    }
+    /**
+     * Creates an error result object
+     * @param type Error type
+     * @param message Error message
+     * @param originalError Original error object
+     * @returns Error result
+     */
+    createErrorResult(type, message, originalError) {
+        console.error(`PDF Embedder Error (${type}): ${message}`);
+        if (originalError) {
+            console.error(originalError);
+        }
+        return {
+            success: false,
+            error: {
+                type,
+                message,
+                originalError
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/formats/pdf/pdf.extractor.d.ts

@@ -0,0 +1,49 @@
+import { InvoiceFormat } from '../../interfaces/common.js';
+/**
+ * Error types for PDF extraction operations
+ */
+export declare enum PDFExtractError {
+    EXTRACT_ERROR = "XML extraction failed",
+    INVALID_INPUT = "Invalid input parameters",
+    NO_XML_FOUND = "No XML found in PDF"
+}
+/**
+ * Result of a PDF extraction operation
+ */
+export interface PDFExtractResult {
+    success: boolean;
+    xml?: string;
+    format?: InvoiceFormat;
+    extractorUsed?: string;
+    error?: {
+        type: PDFExtractError;
+        message: string;
+        originalError?: Error;
+    };
+}
+/**
+ * Main PDF extractor class that orchestrates the extraction process
+ * Uses multiple specialized extractors in sequence to maximize success rate
+ */
+export declare class PDFExtractor {
+    private extractors;
+    /**
+     * Constructor initializes the chain of extractors
+     */
+    constructor();
+    /**
+     * Extract XML from a PDF buffer
+     * Tries multiple extraction methods in sequence
+     * @param pdfBuffer PDF buffer
+     * @returns Result with either the extracted XML or error information
+     */
+    extractXml(pdfBuffer: Uint8Array | Buffer): Promise<PDFExtractResult>;
+    /**
+     * Create a PDF extract result with error information
+     * @param type Error type
+     * @param message Error message
+     * @param originalError Original error object
+     * @returns Error result
+     */
+    private createErrorResult;
+}

package/dist_ts/formats/pdf/pdf.extractor.js

@@ -0,0 +1,98 @@
+import { BaseXMLExtractor, StandardXMLExtractor, AssociatedFilesExtractor, TextXMLExtractor } from './extractors/index.js';
+import { FormatDetector } from '../utils/format.detector.js';
+import { InvoiceFormat } from '../../interfaces/common.js';
+/**
+ * Error types for PDF extraction operations
+ */
+export var PDFExtractError;
+(function (PDFExtractError) {
+    PDFExtractError["EXTRACT_ERROR"] = "XML extraction failed";
+    PDFExtractError["INVALID_INPUT"] = "Invalid input parameters";
+    PDFExtractError["NO_XML_FOUND"] = "No XML found in PDF";
+})(PDFExtractError || (PDFExtractError = {}));
+/**
+ * Main PDF extractor class that orchestrates the extraction process
+ * Uses multiple specialized extractors in sequence to maximize success rate
+ */
+export class PDFExtractor {
+    /**
+     * Constructor initializes the chain of extractors
+     */
+    constructor() {
+        this.extractors = [];
+        // Add extractors in order of preference/likelihood of success
+        this.extractors.push(new StandardXMLExtractor(), // Standard PDF/A-3 embedded files
+        new AssociatedFilesExtractor(), // Associated files (ZUGFeRD v1, some Factur-X)
+        new TextXMLExtractor() // Text-based extraction (fallback)
+        );
+    }
+    /**
+     * Extract XML from a PDF buffer
+     * Tries multiple extraction methods in sequence
+     * @param pdfBuffer PDF buffer
+     * @returns Result with either the extracted XML or error information
+     */
+    async extractXml(pdfBuffer) {
+        try {
+            console.log('Starting XML extraction from PDF...');
+            // Validate input
+            if (!pdfBuffer || pdfBuffer.length === 0) {
+                return this.createErrorResult(PDFExtractError.INVALID_INPUT, 'PDF buffer is empty or undefined');
+            }
+            // Ensure buffer is Uint8Array
+            const pdfBufferArray = Buffer.isBuffer(pdfBuffer) ? new Uint8Array(pdfBuffer) : pdfBuffer;
+            // Try each extractor in sequence
+            for (const extractor of this.extractors) {
+                const extractorName = extractor.constructor.name;
+                console.log(`Trying extraction with ${extractorName}...`);
+                try {
+                    const xml = await extractor.extractXml(pdfBufferArray);
+                    if (xml) {
+                        console.log(`Successfully extracted XML using ${extractorName}`);
+                        // Detect format of the extracted XML
+                        const format = FormatDetector.detectFormat(xml);
+                        return {
+                            success: true,
+                            xml,
+                            format,
+                            extractorUsed: extractorName
+                        };
+                    }
+                    console.log(`Extraction with ${extractorName} failed, trying next method...`);
+                }
+                catch (error) {
+                    // Log error but continue with next extractor
+                    console.warn(`Error using ${extractorName}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            // If all extractors fail, return a no XML found error
+            return this.createErrorResult(PDFExtractError.NO_XML_FOUND, 'All extraction methods failed, no valid XML found in PDF');
+        }
+        catch (error) {
+            // Handle any unexpected errors
+            return this.createErrorResult(PDFExtractError.EXTRACT_ERROR, `Unexpected error during XML extraction: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Create a PDF extract result with error information
+     * @param type Error type
+     * @param message Error message
+     * @param originalError Original error object
+     * @returns Error result
+     */
+    createErrorResult(type, message, originalError) {
+        console.error(`PDF Extractor Error (${type}): ${message}`);
+        if (originalError) {
+            console.error(originalError);
+        }
+        return {
+            success: false,
+            error: {
+                type,
+                message,
+                originalError
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/formats/pdf/robust-pdf.extractor.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Class for extracting XML from PDF files with robust error handling
+ */
+export declare class RobustPDFExtractor {
+    /**
+     * Extracts XML from a PDF buffer
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    extractXml(pdfBuffer: Uint8Array | Buffer): Promise<string | null>;
+    /**
+     * Standard extraction method using PDF-lib
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    private standardExtraction;
+    /**
+     * Alternative extraction method using a more robust approach
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    private alternativeExtraction;
+    /**
+     * Extracts XML from a string
+     * @param pdfString PDF string
+     * @returns XML content or null if not found
+     */
+    private extractXmlFromString;
+    /**
+     * Checks if an XML string is valid
+     * @param xmlString XML string to check
+     * @returns True if the XML is valid
+     */
+    private isValidXml;
+    /**
+     * Extracts a sample XML file for testing
+     * @returns Sample XML content
+     */
+    private extractSampleXml;
+}