@fin.cx/einvoice 5.0.2

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

@@ -0,0 +1,14 @@
+import { BaseXMLExtractor } from './base.extractor.js';
+/**
+ * Associated files extractor for PDF/A-3 documents
+ * Extracts XML from associated files (AF entry in the catalog)
+ * Particularly useful for ZUGFeRD v1 and some Factur-X documents
+ */
+export declare class AssociatedFilesExtractor extends BaseXMLExtractor {
+    /**
+     * Extract XML from a PDF buffer using associated files
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    extractXml(pdfBuffer: Uint8Array | Buffer): Promise<string | null>;
+}

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

@@ -0,0 +1,68 @@
+import { PDFDocument, PDFDict, PDFName, PDFRawStream, PDFArray, PDFString } from '../../../plugins.js';
+import { BaseXMLExtractor } from './base.extractor.js';
+/**
+ * Associated files extractor for PDF/A-3 documents
+ * Extracts XML from associated files (AF entry in the catalog)
+ * Particularly useful for ZUGFeRD v1 and some Factur-X documents
+ */
+export class AssociatedFilesExtractor extends BaseXMLExtractor {
+    /**
+     * Extract XML from a PDF buffer using associated files
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    async extractXml(pdfBuffer) {
+        try {
+            const pdfDoc = await PDFDocument.load(pdfBuffer);
+            // Try to find associated files via the AF entry in the catalog
+            const afArray = pdfDoc.catalog.lookup(PDFName.of('AF'));
+            if (!(afArray instanceof PDFArray)) {
+                console.warn('No AF (Associated Files) entry found in PDF catalog');
+                return null;
+            }
+            // Process each associated file
+            for (let i = 0; i < afArray.size(); i++) {
+                const fileSpec = afArray.lookup(i);
+                if (!(fileSpec instanceof PDFDict)) {
+                    continue;
+                }
+                // Get the file name
+                const fileNameObj = fileSpec.lookup(PDFName.of('F')) || fileSpec.lookup(PDFName.of('UF'));
+                if (!(fileNameObj instanceof PDFString)) {
+                    continue;
+                }
+                const fileName = fileNameObj.decodeText();
+                // Check if it's a known invoice XML file name
+                const isKnownFileName = this.knownFileNames.some(knownName => fileName.toLowerCase() === knownName.toLowerCase());
+                // Check if it's any XML file or has invoice-related keywords
+                const isXmlFile = fileName.toLowerCase().endsWith('.xml') ||
+                    fileName.toLowerCase().includes('zugferd') ||
+                    fileName.toLowerCase().includes('factur-x') ||
+                    fileName.toLowerCase().includes('xrechnung') ||
+                    fileName.toLowerCase().includes('invoice');
+                if (isKnownFileName || isXmlFile) {
+                    // Get the embedded file dictionary
+                    const efDict = fileSpec.lookup(PDFName.of('EF'));
+                    if (!(efDict instanceof PDFDict)) {
+                        continue;
+                    }
+                    // Get the file stream
+                    const fileStream = efDict.lookup(PDFName.of('F'));
+                    if (fileStream instanceof PDFRawStream) {
+                        const xmlContent = await this.extractXmlFromStream(fileStream, fileName);
+                        if (xmlContent) {
+                            return xmlContent;
+                        }
+                    }
+                }
+            }
+            console.warn('No valid XML found in associated files');
+            return null;
+        }
+        catch (error) {
+            console.error('Error in associated files extraction:', error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,92 @@
+import { PDFRawStream } from '../../../plugins.js';
+/**
+ * Base class for PDF XML extractors with common functionality
+ */
+export declare abstract class BaseXMLExtractor {
+    /**
+     * Known XML file names for different invoice formats
+     */
+    protected readonly knownFileNames: string[];
+    /**
+     * Known XML formats to validate extracted content
+     */
+    protected readonly knownFormats: string[];
+    /**
+     * Known XML end tags for extracting content from strings
+     */
+    protected readonly knownEndTags: string[];
+    /**
+     * Extract XML from a PDF buffer
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    abstract extractXml(pdfBuffer: Uint8Array | Buffer): Promise<string | null>;
+    /**
+     * Check if an XML string is valid
+     * @param xmlString XML string to check
+     * @returns True if the XML is valid
+     */
+    protected isValidXml(xmlString: string): boolean;
+    /**
+     * Check if the XML string contains a known element
+     * @param xmlString XML string to check
+     * @returns True if the XML contains a known element
+     */
+    protected hasKnownXmlElement(xmlString: string): boolean;
+    /**
+     * Check if the XML string contains a known format
+     * @param xmlString XML string to check
+     * @returns True if the XML contains a known format
+     */
+    protected hasKnownFormat(xmlString: string): boolean;
+    /**
+     * Check if the XML string has a proper structure
+     * @param xmlString XML string to check
+     * @returns True if the XML has a proper structure
+     */
+    protected hasProperXmlStructure(xmlString: string): boolean;
+    /**
+     * Check if the XML string contains binary data
+     * @param xmlString XML string to check
+     * @returns True if the XML contains binary data
+     */
+    protected hasBinaryData(xmlString: string): boolean;
+    /**
+     * Extract XML from a string
+     * @param text Text to extract XML from
+     * @param startIndex Index to start extraction from
+     * @returns XML content or null if not found
+     */
+    protected extractXmlFromString(text: string, startIndex?: number): string | null;
+    /**
+     * Decompress and decode XML content from a PDF stream
+     * @param stream PDF stream containing XML data
+     * @param fileName Name of the file (for logging)
+     * @returns XML content or null if not valid
+     */
+    protected extractXmlFromStream(stream: PDFRawStream, fileName: string): Promise<string | null>;
+    /**
+     * Try to decompress a buffer using different methods
+     * @param buffer Buffer to decompress
+     * @returns Decompressed buffer or null if decompression failed
+     */
+    protected tryDecompress(buffer: Uint8Array): Uint8Array | null;
+    /**
+     * Try to decode a buffer to a string using different encodings
+     * @param buffer Buffer to decode
+     * @returns Decoded string or null if decoding failed
+     */
+    protected tryDecodeBuffer(buffer: Uint8Array): string | null;
+    /**
+     * Decode a buffer using ISO-8859-1 (Latin1) encoding
+     * @param buffer Buffer to decode
+     * @returns Decoded string
+     */
+    protected decodeLatin1(buffer: Uint8Array): string;
+    /**
+     * Check if a string is plausibly XML (quick check before validation)
+     * @param content String to check
+     * @returns True if the string is plausibly XML
+     */
+    protected isPlausibleXml(content: string): boolean;
+}

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

@@ -0,0 +1,319 @@
+import { PDFDocument, PDFDict, PDFName, PDFRawStream, PDFArray, PDFString, pako } from '../../../plugins.js';
+/**
+ * Base class for PDF XML extractors with common functionality
+ */
+export class BaseXMLExtractor {
+    constructor() {
+        /**
+         * Known XML file names for different invoice formats
+         */
+        this.knownFileNames = [
+            'factur-x.xml',
+            'zugferd-invoice.xml',
+            'ZUGFeRD-invoice.xml',
+            'xrechnung.xml',
+            'ubl-invoice.xml',
+            'invoice.xml',
+            'metadata.xml'
+        ];
+        /**
+         * Known XML formats to validate extracted content
+         */
+        this.knownFormats = [
+            'CrossIndustryInvoice',
+            'CrossIndustryDocument',
+            'Invoice',
+            'CreditNote',
+            'ubl:Invoice',
+            'ubl:CreditNote',
+            'rsm:CrossIndustryInvoice',
+            'rsm:CrossIndustryDocument',
+            'ram:CrossIndustryDocument',
+            'urn:un:unece:uncefact',
+            'urn:ferd:CrossIndustryDocument',
+            'urn:zugferd',
+            'urn:factur-x',
+            'factur-x.eu',
+            'ZUGFeRD',
+            'FatturaElettronica'
+        ];
+        /**
+         * Known XML end tags for extracting content from strings
+         */
+        this.knownEndTags = [
+            '</CrossIndustryInvoice>',
+            '</CrossIndustryDocument>',
+            '</Invoice>',
+            '</CreditNote>',
+            '</rsm:CrossIndustryInvoice>',
+            '</rsm:CrossIndustryDocument>',
+            '</ram:CrossIndustryDocument>',
+            '</ubl:Invoice>',
+            '</ubl:CreditNote>',
+            '</FatturaElettronica>'
+        ];
+    }
+    /**
+     * Check if an XML string is valid
+     * @param xmlString XML string to check
+     * @returns True if the XML is valid
+     */
+    isValidXml(xmlString) {
+        try {
+            // Basic checks for XML validity
+            if (!xmlString || typeof xmlString !== 'string') {
+                return false;
+            }
+            // Check if it starts with XML declaration or a valid element
+            if (!xmlString.includes('<?xml') && !this.hasKnownXmlElement(xmlString)) {
+                return false;
+            }
+            // Check if the XML string contains known invoice formats
+            const hasKnownFormat = this.hasKnownFormat(xmlString);
+            if (!hasKnownFormat) {
+                return false;
+            }
+            // Check if the XML string contains binary data or invalid characters
+            if (this.hasBinaryData(xmlString)) {
+                return false;
+            }
+            // Check if the XML string is too short
+            if (xmlString.length < 100) {
+                return false;
+            }
+            // Check if XML has a proper structure (contains both opening and closing tags)
+            if (!this.hasProperXmlStructure(xmlString)) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error validating XML:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if the XML string contains a known element
+     * @param xmlString XML string to check
+     * @returns True if the XML contains a known element
+     */
+    hasKnownXmlElement(xmlString) {
+        for (const format of this.knownFormats) {
+            // Check for opening tag of format
+            if (xmlString.includes(`<${format}`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if the XML string contains a known format
+     * @param xmlString XML string to check
+     * @returns True if the XML contains a known format
+     */
+    hasKnownFormat(xmlString) {
+        for (const format of this.knownFormats) {
+            if (xmlString.includes(format)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if the XML string has a proper structure
+     * @param xmlString XML string to check
+     * @returns True if the XML has a proper structure
+     */
+    hasProperXmlStructure(xmlString) {
+        // Check for at least one matching opening and closing tag
+        for (const endTag of this.knownEndTags) {
+            const startTag = endTag.replace('/', '');
+            if (xmlString.includes(startTag) && xmlString.includes(endTag)) {
+                return true;
+            }
+        }
+        // If no specific tag is found but it has a basic XML structure
+        return ((xmlString.includes('<?xml') && xmlString.includes('?>')) ||
+            (xmlString.match(/<[^>]+>/) !== null && xmlString.match(/<\/[^>]+>/) !== null));
+    }
+    /**
+     * Check if the XML string contains binary data
+     * @param xmlString XML string to check
+     * @returns True if the XML contains binary data
+     */
+    hasBinaryData(xmlString) {
+        // Check for common binary data indicators
+        const binaryChars = ['\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005'];
+        const consecutiveNulls = '\u0000\u0000\u0000';
+        // Check for control characters that shouldn't be in XML
+        if (binaryChars.some(char => xmlString.includes(char))) {
+            return true;
+        }
+        // Check for consecutive null bytes which indicate binary data
+        if (xmlString.includes(consecutiveNulls)) {
+            return true;
+        }
+        // Check for high concentration of non-printable characters
+        const nonPrintableCount = (xmlString.match(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g) || []).length;
+        if (nonPrintableCount > xmlString.length * 0.05) { // More than 5% non-printable
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Extract XML from a string
+     * @param text Text to extract XML from
+     * @param startIndex Index to start extraction from
+     * @returns XML content or null if not found
+     */
+    extractXmlFromString(text, startIndex = 0) {
+        try {
+            // Find the start of the XML document
+            let xmlStartIndex = text.indexOf('<?xml', startIndex);
+            // If no XML declaration, try to find known elements
+            if (xmlStartIndex === -1) {
+                for (const format of this.knownFormats) {
+                    const formatStartIndex = text.indexOf(`<${format.split(':').pop()}`, startIndex);
+                    if (formatStartIndex !== -1) {
+                        xmlStartIndex = formatStartIndex;
+                        break;
+                    }
+                }
+                // Still didn't find any start marker
+                if (xmlStartIndex === -1) {
+                    return null;
+                }
+            }
+            // Try to find the end of the XML document
+            let xmlEndIndex = -1;
+            for (const endTag of this.knownEndTags) {
+                const endIndex = text.indexOf(endTag, xmlStartIndex);
+                if (endIndex !== -1) {
+                    xmlEndIndex = endIndex + endTag.length;
+                    break;
+                }
+            }
+            // If no known end tag found, try to use a heuristic approach
+            if (xmlEndIndex === -1) {
+                // Try to find the last closing tag
+                const lastClosingTagMatch = text.slice(xmlStartIndex).match(/<\/[^>]+>(?!.*<\/[^>]+>)/);
+                if (lastClosingTagMatch && lastClosingTagMatch.index !== undefined) {
+                    xmlEndIndex = xmlStartIndex + lastClosingTagMatch.index + lastClosingTagMatch[0].length;
+                }
+                else {
+                    return null;
+                }
+            }
+            // Extract the XML content
+            const xmlContent = text.substring(xmlStartIndex, xmlEndIndex);
+            // Validate the extracted content
+            if (this.isValidXml(xmlContent)) {
+                return xmlContent;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error extracting XML from string:', error);
+            return null;
+        }
+    }
+    /**
+     * Decompress and decode XML content from a PDF stream
+     * @param stream PDF stream containing XML data
+     * @param fileName Name of the file (for logging)
+     * @returns XML content or null if not valid
+     */
+    async extractXmlFromStream(stream, fileName) {
+        try {
+            // Get the raw bytes from the stream
+            const rawBytes = stream.getContents();
+            // First try without decompression (in case the content is not compressed)
+            let xmlContent = this.tryDecodeBuffer(rawBytes);
+            if (xmlContent && this.isValidXml(xmlContent)) {
+                console.log(`Successfully extracted uncompressed XML from PDF file. File name: ${fileName}`);
+                return xmlContent;
+            }
+            // Try with decompression
+            try {
+                const decompressedBytes = this.tryDecompress(rawBytes);
+                if (decompressedBytes) {
+                    xmlContent = this.tryDecodeBuffer(decompressedBytes);
+                    if (xmlContent && this.isValidXml(xmlContent)) {
+                        console.log(`Successfully extracted decompressed XML from PDF file. File name: ${fileName}`);
+                        return xmlContent;
+                    }
+                }
+            }
+            catch (decompressError) {
+                console.log(`Decompression failed for ${fileName}: ${decompressError}`);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error extracting XML from stream:', error);
+            return null;
+        }
+    }
+    /**
+     * Try to decompress a buffer using different methods
+     * @param buffer Buffer to decompress
+     * @returns Decompressed buffer or null if decompression failed
+     */
+    tryDecompress(buffer) {
+        try {
+            // Try pako inflate (for deflate/zlib compression)
+            return pako.inflate(buffer);
+        }
+        catch (error) {
+            // If pako fails, try other methods if needed
+            console.warn('Pako decompression failed, might be uncompressed or using a different algorithm');
+            return null;
+        }
+    }
+    /**
+     * Try to decode a buffer to a string using different encodings
+     * @param buffer Buffer to decode
+     * @returns Decoded string or null if decoding failed
+     */
+    tryDecodeBuffer(buffer) {
+        try {
+            // Try UTF-8 first
+            let content = new TextDecoder('utf-8').decode(buffer);
+            if (this.isPlausibleXml(content)) {
+                return content;
+            }
+            // Try ISO-8859-1 (Latin1)
+            content = this.decodeLatin1(buffer);
+            if (this.isPlausibleXml(content)) {
+                return content;
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn('Error decoding buffer:', error);
+            return null;
+        }
+    }
+    /**
+     * Decode a buffer using ISO-8859-1 (Latin1) encoding
+     * @param buffer Buffer to decode
+     * @returns Decoded string
+     */
+    decodeLatin1(buffer) {
+        return Array.from(buffer)
+            .map(byte => String.fromCharCode(byte))
+            .join('');
+    }
+    /**
+     * Check if a string is plausibly XML (quick check before validation)
+     * @param content String to check
+     * @returns True if the string is plausibly XML
+     */
+    isPlausibleXml(content) {
+        return content.includes('<') &&
+            content.includes('>') &&
+            (content.includes('<?xml') ||
+                this.knownFormats.some(format => content.includes(format)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.extractor.js","sourceRoot":"","sources":["../../../../ts/formats/pdf/extractors/base.extractor.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/pdf/extractors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base.extractor.js';
+export * from './standard.extractor.js';
+export * from './associated.extractor.js';
+export * from './text.extractor.js';

package/dist_ts/formats/pdf/extractors/index.js

@@ -0,0 +1,5 @@
+export * from './base.extractor.js';
+export * from './standard.extractor.js';
+export * from './associated.extractor.js';
+export * from './text.extractor.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9mb3JtYXRzL3BkZi9leHRyYWN0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMscUJBQXFCLENBQUMifQ==

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

@@ -0,0 +1,13 @@
+import { BaseXMLExtractor } from './base.extractor.js';
+/**
+ * Standard PDF XML extractor that extracts XML from embedded files
+ * Works with PDF/A-3 documents that follow the standard for embedding files
+ */
+export declare class StandardXMLExtractor extends BaseXMLExtractor {
+    /**
+     * Extract XML from a PDF buffer using standard PDF/A-3 embedded files
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    extractXml(pdfBuffer: Uint8Array | Buffer): Promise<string | null>;
+}

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

@@ -0,0 +1,74 @@
+import { PDFDocument, PDFDict, PDFName, PDFRawStream, PDFArray, PDFString } from '../../../plugins.js';
+import { BaseXMLExtractor } from './base.extractor.js';
+/**
+ * Standard PDF XML extractor that extracts XML from embedded files
+ * Works with PDF/A-3 documents that follow the standard for embedding files
+ */
+export class StandardXMLExtractor extends BaseXMLExtractor {
+    /**
+     * Extract XML from a PDF buffer using standard PDF/A-3 embedded files
+     * @param pdfBuffer PDF buffer
+     * @returns XML content or null if not found
+     */
+    async extractXml(pdfBuffer) {
+        try {
+            const pdfDoc = await PDFDocument.load(pdfBuffer);
+            // Get the document's metadata dictionary
+            const namesDictObj = pdfDoc.catalog.lookup(PDFName.of('Names'));
+            if (!(namesDictObj instanceof PDFDict)) {
+                console.warn('No Names dictionary found in PDF! This PDF does not contain embedded files.');
+                return null;
+            }
+            // Get the embedded files dictionary
+            const embeddedFilesDictObj = namesDictObj.lookup(PDFName.of('EmbeddedFiles'));
+            if (!(embeddedFilesDictObj instanceof PDFDict)) {
+                console.warn('No EmbeddedFiles dictionary found! This PDF does not contain embedded files.');
+                return null;
+            }
+            // Get the names array
+            const filesSpecObj = embeddedFilesDictObj.lookup(PDFName.of('Names'));
+            if (!(filesSpecObj instanceof PDFArray)) {
+                console.warn('No files specified in EmbeddedFiles dictionary!');
+                return null;
+            }
+            // Try to find an XML file in the embedded files
+            for (let i = 0; i < filesSpecObj.size(); i += 2) {
+                const fileNameObj = filesSpecObj.lookup(i);
+                const fileSpecObj = filesSpecObj.lookup(i + 1);
+                if (!(fileNameObj instanceof PDFString) || !(fileSpecObj instanceof PDFDict)) {
+                    continue;
+                }
+                // Get the filename as string
+                const fileName = fileNameObj.decodeText();
+                // Check if it's a known invoice XML file name
+                const isKnownFileName = this.knownFileNames.some(knownName => fileName.toLowerCase() === knownName.toLowerCase());
+                // Check if it's any XML file or has invoice-related keywords
+                const isXmlFile = fileName.toLowerCase().endsWith('.xml') ||
+                    fileName.toLowerCase().includes('zugferd') ||
+                    fileName.toLowerCase().includes('factur-x') ||
+                    fileName.toLowerCase().includes('xrechnung') ||
+                    fileName.toLowerCase().includes('invoice');
+                if (isKnownFileName || isXmlFile) {
+                    const efDictObj = fileSpecObj.lookup(PDFName.of('EF'));
+                    if (!(efDictObj instanceof PDFDict)) {
+                        continue;
+                    }
+                    const fileStream = efDictObj.lookup(PDFName.of('F'));
+                    if (fileStream instanceof PDFRawStream) {
+                        const xmlContent = await this.extractXmlFromStream(fileStream, fileName);
+                        if (xmlContent) {
+                            return xmlContent;
+                        }
+                    }
+                }
+            }
+            console.warn('No valid XML found in embedded files');
+            return null;
+        }
+        catch (error) {
+            console.error('Error in standard extraction:', error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmQuZXh0cmFjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvZm9ybWF0cy9wZGYvZXh0cmFjdG9ycy9zdGFuZGFyZC5leHRyYWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDdkcsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFdkQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLG9CQUFxQixTQUFRLGdCQUFnQjtJQUN4RDs7OztPQUlHO0lBQ0ksS0FBSyxDQUFDLFVBQVUsQ0FBQyxTQUE4QjtRQUNwRCxJQUFJLENBQUM7WUFDSCxNQUFNLE1BQU0sR0FBRyxNQUFNLFdBQVcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7WUFFakQseUNBQXlDO1lBQ3pDLE1BQU0sWUFBWSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztZQUNoRSxJQUFJLENBQUMsQ0FBQyxZQUFZLFlBQVksT0FBTyxDQUFDLEVBQUUsQ0FBQztnQkFDdkMsT0FBTyxDQUFDLElBQUksQ0FBQyw2RUFBNkUsQ0FBQyxDQUFDO2dCQUM1RixPQUFPLElBQUksQ0FBQztZQUNkLENBQUM7WUFFRCxvQ0FBb0M7WUFDcEMsTUFBTSxvQkFBb0IsR0FBRyxZQUFZLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQztZQUM5RSxJQUFJLENBQUMsQ0FBQyxvQkFBb0IsWUFBWSxPQUFPLENBQUMsRUFBRSxDQUFDO2dCQUMvQyxPQUFPLENBQUMsSUFBSSxDQUFDLDhFQUE4RSxDQUFDLENBQUM7Z0JBQzdGLE9BQU8sSUFBSSxDQUFDO1lBQ2QsQ0FBQztZQUVELHNCQUFzQjtZQUN0QixNQUFNLFlBQVksR0FBRyxvQkFBb0IsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1lBQ3RFLElBQUksQ0FBQyxDQUFDLFlBQVksWUFBWSxRQUFRLENBQUMsRUFBRSxDQUFDO2dCQUN4QyxPQUFPLENBQUMsSUFBSSxDQUFDLGlEQUFpRCxDQUFDLENBQUM7Z0JBQ2hFLE9BQU8sSUFBSSxDQUFDO1lBQ2QsQ0FBQztZQUVELGdEQUFnRDtZQUNoRCxLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsWUFBWSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztnQkFDaEQsTUFBTSxXQUFXLEdBQUcsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDM0MsTUFBTSxXQUFXLEdBQUcsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7Z0JBRS9DLElBQUksQ0FBQyxDQUFDLFdBQVcsWUFBWSxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsV0FBVyxZQUFZLE9BQU8sQ0FBQyxFQUFFLENBQUM7b0JBQzdFLFNBQVM7Z0JBQ1gsQ0FBQztnQkFFRCw2QkFBNkI7Z0JBQzdCLE1BQU0sUUFBUSxHQUFHLFdBQVcsQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFFMUMsOENBQThDO2dCQUM5QyxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FDOUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsV0FBVyxFQUFFLEtBQUssU0FBUyxDQUFDLFdBQVcsRUFBRSxDQUNoRSxDQUFDO2dCQUVGLDZEQUE2RDtnQkFDN0QsTUFBTSxTQUFTLEdBQUcsUUFBUSxDQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUM7b0JBQ3ZDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDO29CQUMxQyxRQUFRLENBQUMsV0FBVyxFQUFFLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQztvQkFDM0MsUUFBUSxDQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUM7b0JBQzVDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUM7Z0JBRTdELElBQUksZUFBZSxJQUFJLFNBQVMsRUFBRSxDQUFDO29CQUNqQyxNQUFNLFNBQVMsR0FBRyxXQUFXLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztvQkFDdkQsSUFBSSxDQUFDLENBQUMsU0FBUyxZQUFZLE9BQU8sQ0FBQyxFQUFFLENBQUM7d0JBQ3BDLFNBQVM7b0JBQ1gsQ0FBQztvQkFFRCxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztvQkFDckQsSUFBSSxVQUFVLFlBQVksWUFBWSxFQUFFLENBQUM7d0JBQ3ZDLE1BQU0sVUFBVSxHQUFHLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixDQUFDLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQzt3QkFDekUsSUFBSSxVQUFVLEVBQUUsQ0FBQzs0QkFDZixPQUFPLFVBQVUsQ0FBQzt3QkFDcEIsQ0FBQztvQkFDSCxDQUFDO2dCQUNILENBQUM7WUFDSCxDQUFDO1lBRUQsT0FBTyxDQUFDLElBQUksQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDO1lBQ3JELE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLENBQUMsS0FBSyxDQUFDLCtCQUErQixFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ3RELE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,45 @@
+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 declare class TextXMLExtractor extends BaseXMLExtractor {
+    private readonly CHUNK_SIZE;
+    private readonly MAX_CHUNKS;
+    private readonly XML_PATTERNS;
+    /**
+     * 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
+     */
+    extractXml(pdfBuffer: Uint8Array | Buffer): Promise<string | 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
+     */
+    private extractXmlFromBufferChunked;
+    /**
+     * 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
+     */
+    private processChunk;
+    /**
+     * 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
+     */
+    private decodeBufferToString;
+    /**
+     * Search for XML patterns in a string
+     * @param content String to search in
+     * @returns XML content or null if not found
+     */
+    private searchForXmlInString;
+}