@fin.cx/einvoice 5.1.4 → 5.2.1

package/ts/einvoice.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
 
-import { business, finance } from './plugins.js';
+import type { business, finance } from '@tsclass/tsclass';
 import type { TInvoice, TAccountingDocItem } from '@tsclass/tsclass/dist_ts/finance/index.js';
 import { InvoiceFormat, ValidationLevel } from './interfaces/common.js';
 import type { ValidationResult, ValidationError, EInvoiceOptions, IPdf, ExportFormat } from './interfaces/common.js';
@@ -20,14 +20,11 @@ import { DecoderFactory } from './formats/factories/decoder.factory.js';
 import { EncoderFactory } from './formats/factories/encoder.factory.js';
 import { ValidatorFactory } from './formats/factories/validator.factory.js';
 
-// Import PDF utilities
-import { PDFEmbedder } from './formats/pdf/pdf.embedder.js';
-import { PDFExtractor } from './formats/pdf/pdf.extractor.js';
-
 // Import format detector
 import { FormatDetector } from './formats/utils/format.detector.js';
 
 // Import enhanced validators
+import { EN16931Validator } from './formats/validation/en16931.validator.js';
 import { EN16931BusinessRulesValidator } from './formats/validation/en16931.business-rules.validator.js';
 import { CodeListValidator } from './formats/validation/codelist.validator.js';
 import type { ValidationOptions } from './formats/validation/validation.types.js';
@@ -41,6 +38,9 @@ import type { IEInvoiceMetadata } from './interfaces/en16931-metadata.js';
  * Extends the TInvoice interface for seamless integration with existing systems
  */
 export class EInvoice implements TInvoice {
+  private static sharedPdfEmbedder?: import('./formats/pdf/pdf.embedder.js').PDFEmbedder;
+  private static sharedPdfExtractor?: import('./formats/pdf/pdf.extractor.js').PDFExtractor;
+
   /**
    * Creates an EInvoice instance from XML string
    * @param xmlString XML string to parse
@@ -75,7 +75,8 @@ export class EInvoice implements TInvoice {
       await invoice.fromPdfFile(pdfBuffer);
     } else {
       // If given a buffer, extract XML and parse it
-      const extractResult = await invoice.pdfExtractor.extractXml(pdfBuffer);
+      const pdfExtractor = await invoice.getPdfExtractor();
+      const extractResult = await pdfExtractor.extractXml(pdfBuffer);
       if (!extractResult.success || !extractResult.xml) {
         throw new EInvoicePDFError('No invoice XML found in PDF', 'extract');
       }
@@ -109,8 +110,8 @@ export class EInvoice implements TInvoice {
   public incidenceId: string = '';
   public language: string = 'en';
   public objectActions: any[] = [];
-  public pdf: IPdf | null = null;
-  public pdfAttachments: IPdf[] | null = null;
+  public pdf?: IPdf;
+  public pdfAttachments?: IPdf[];
   public accentColor: string | null = null;
   public logoUrl: string | null = null;
 
@@ -149,7 +150,13 @@ export class EInvoice implements TInvoice {
            this.accountingDocType === 'creditnote' ? 'creditnote' : 'debitnote';
   }
   public set invoiceType(value: 'invoice' | 'creditnote' | 'debitnote') {
-    this.accountingDocType = 'invoice'; // Always set to invoice for TInvoice type
+    if (value !== 'invoice') {
+      throw new EInvoiceFormatError(
+        `Unsupported invoice type: ${value}`,
+        { unsupportedFeatures: [`invoiceType=${value}`] }
+      );
+    }
+    this.accountingDocType = 'invoice';
   }
   
   // Computed properties for convenience
@@ -181,15 +188,30 @@ export class EInvoice implements TInvoice {
   
   private xmlString: string = '';
   private detectedFormat: InvoiceFormat = InvoiceFormat.UNKNOWN;
+  private parsedXmlDocument?: Document;
   private validationErrors: ValidationError[] = [];
+  private validationCache = new Map<string, ValidationResult>();
   private options: EInvoiceOptions = {
     validateOnLoad: false,
     validationLevel: ValidationLevel.SYNTAX
   };
 
-  // PDF utilities
-  private pdfEmbedder = new PDFEmbedder();
-  private pdfExtractor = new PDFExtractor();
+  // PDF utilities are created lazily because most invoice workflows never touch PDF I/O.
+  private async getPdfEmbedder(): Promise<import('./formats/pdf/pdf.embedder.js').PDFEmbedder> {
+    if (!EInvoice.sharedPdfEmbedder) {
+      const { PDFEmbedder } = await import('./formats/pdf/pdf.embedder.js');
+      EInvoice.sharedPdfEmbedder = new PDFEmbedder();
+    }
+    return EInvoice.sharedPdfEmbedder;
+  }
+
+  private async getPdfExtractor(): Promise<import('./formats/pdf/pdf.extractor.js').PDFExtractor> {
+    if (!EInvoice.sharedPdfExtractor) {
+      const { PDFExtractor } = await import('./formats/pdf/pdf.extractor.js');
+      EInvoice.sharedPdfExtractor = new PDFExtractor();
+    }
+    return EInvoice.sharedPdfExtractor;
+  }
 
   /**
    * Creates a new EInvoice instance
@@ -260,6 +282,7 @@ export class EInvoice implements TInvoice {
    */
   public async fromXmlString(xmlString: string): Promise<EInvoice> {
     try {
+      this.validationCache.clear();
       this.xmlString = xmlString;
       
       // Detect format
@@ -269,8 +292,13 @@ export class EInvoice implements TInvoice {
       }
 
       // Get appropriate decoder
-      const decoder = DecoderFactory.createDecoder(xmlString, !this.options.validateOnLoad);
+      const decoder = DecoderFactory.createDecoder(
+        xmlString,
+        !this.options.validateOnLoad,
+        this.detectedFormat,
+      );
       const invoice = await decoder.decode();
+      this.parsedXmlDocument = decoder.getParsedDocument();
       
       // Map the decoded invoice to our properties
       this.mapFromTInvoice(invoice);
@@ -282,10 +310,11 @@ export class EInvoice implements TInvoice {
 
       return this;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoiceParsingError(`Failed to parse XML: ${error.message}`, {}, error as Error);
+      throw new EInvoiceParsingError(`Failed to parse XML: ${errorMessage}`, {}, error as Error);
     }
   }
 
@@ -307,7 +336,8 @@ export class EInvoice implements TInvoice {
       const xmlString = fileBuffer.toString('utf-8');
       return this.fromXmlString(xmlString);
     } catch (error) {
-      throw new EInvoiceError(`Failed to load file: ${error.message}`, 'FILE_LOAD_ERROR', { filePath });
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new EInvoiceError(`Failed to load file: ${errorMessage}`, 'FILE_LOAD_ERROR', { filePath });
     }
   }
 
@@ -319,7 +349,8 @@ export class EInvoice implements TInvoice {
   public async fromPdfFile(filePath: string): Promise<EInvoice> {
     try {
       const pdfBuffer = await plugins.fs.readFile(filePath);
-      const extractResult = await this.pdfExtractor.extractXml(pdfBuffer);
+      const pdfExtractor = await this.getPdfExtractor();
+      const extractResult = await pdfExtractor.extractXml(pdfBuffer);
       const extractedXml = extractResult.success ? extractResult.xml : null;
       
       if (!extractedXml) {
@@ -343,10 +374,11 @@ export class EInvoice implements TInvoice {
       
       return this.fromXmlString(extractedXml);
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoicePDFError(`Failed to extract invoice from PDF: ${error.message}`, 'extract', {}, error as Error);
+      throw new EInvoicePDFError(`Failed to extract invoice from PDF: ${errorMessage}`, 'extract', {}, error as Error);
     }
   }
 
@@ -423,7 +455,8 @@ export class EInvoice implements TInvoice {
       
       return await encoder.encode(invoice);
     } catch (error) {
-      throw new EInvoiceFormatError(`Failed to encode to ${format}: ${error.message}`, { targetFormat: format });
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new EInvoiceFormatError(`Failed to encode to ${format}: ${errorMessage}`, { targetFormat: format });
     }
   }
 
@@ -434,21 +467,34 @@ export class EInvoice implements TInvoice {
    */
   public async validate(level: ValidationLevel = ValidationLevel.BUSINESS, options?: ValidationOptions): Promise<ValidationResult> {
     try {
-      // For programmatically created invoices without XML, skip XML-based validation
+      // For programmatically created invoices without XML, validate the in-memory invoice object.
       let result: ValidationResult;
+      const cacheKey = this.getValidationCacheKey(level, options);
+
+      if (cacheKey) {
+        const cached = this.validationCache.get(cacheKey);
+        if (cached) {
+          return this.cloneValidationResult(cached);
+        }
+      }
       
       if (this.xmlString && this.detectedFormat !== InvoiceFormat.UNKNOWN) {
+        if (this.shouldUseFastBusinessValidation(level, options)) {
+          result = this.validateDecodedInvoice(level);
+        } else {
         // Use existing validator for XML-based validation
-        const validator = ValidatorFactory.createValidator(this.xmlString);
-        result = validator.validate(level);
+          const validator = ValidatorFactory.createValidator(
+            this.xmlString,
+            this.detectedFormat,
+            this.parsedXmlDocument,
+          );
+          result = validator.validate(level);
+
+          // Keep the raw XML, but drop the cached DOM once validation is done.
+          this.parsedXmlDocument = undefined;
+        }
       } else {
-        // Create a basic result for programmatically created invoices
-        result = {
-          valid: true,
-          errors: [],
-          warnings: [],
-          level: level
-        };
+        result = this.validateDecodedInvoice(level);
       }
       
       // Enhanced validation with feature flags
@@ -489,16 +535,74 @@ export class EInvoice implements TInvoice {
       // Update validation status
       this.validationErrors = result.errors;
       result.valid = result.errors.length === 0 || options?.reportOnly === true;
+
+      if (cacheKey) {
+        this.validationCache.set(cacheKey, this.cloneValidationResult(result));
+      }
       
       return result;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoiceValidationError(`Validation failed: ${error.message}`, [], { validationLevel: level });
+      throw new EInvoiceValidationError(`Validation failed: ${errorMessage}`, [], { validationLevel: level });
     }
   }
 
+  private validateDecodedInvoice(level: ValidationLevel): ValidationResult {
+    const invoice = this.mapToTInvoice();
+    const errors = EN16931Validator.collectMandatoryFieldErrors(invoice).map(message =>
+      this.createValidationError(message)
+    );
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings: level === ValidationLevel.SYNTAX
+        ? [{
+            code: 'VAL-NO-XML',
+            message: 'Syntax validation was skipped because no XML document has been loaded.'
+          }]
+        : [],
+      level: level
+    };
+  }
+
+  private shouldUseFastBusinessValidation(level: ValidationLevel, options?: ValidationOptions): boolean {
+    if (level !== ValidationLevel.BUSINESS) {
+      return false;
+    }
+
+    if (options?.featureFlags?.length || options?.reportOnly || this.detectedFormat !== InvoiceFormat.UBL) {
+      return false;
+    }
+
+    // For tiny plain-UBL documents without parties or lines, the decoded invoice model already
+    // contains everything needed for the mandatory-field failures the XML validator would report.
+    return this.items.length === 0 && !this.from?.name && !this.to?.name;
+  }
+
+  private getValidationCacheKey(level: ValidationLevel, options?: ValidationOptions): string | undefined {
+    if (!this.xmlString || options) {
+      return undefined;
+    }
+
+    if (level !== ValidationLevel.SYNTAX && level !== ValidationLevel.SEMANTIC) {
+      return undefined;
+    }
+
+    return `xml:${level}`;
+  }
+
+  private cloneValidationResult(result: ValidationResult): ValidationResult {
+    return {
+      ...result,
+      errors: result.errors.map(error => ({ ...error })),
+      warnings: result.warnings?.map(warning => ({ ...warning }))
+    };
+  }
+
   /**
    * Embeds the invoice XML into a PDF
    * @param pdfBuffer The PDF buffer to embed into
@@ -508,13 +612,15 @@ export class EInvoice implements TInvoice {
   public async embedInPdf(pdfBuffer: Buffer, format: ExportFormat = 'facturx'): Promise<Buffer> {
     try {
       const xmlString = await this.toXmlString(format);
-      const embedResult = await this.pdfEmbedder.embedXml(pdfBuffer, xmlString, 'invoice.xml', `${format} Invoice`);
+      const pdfEmbedder = await this.getPdfEmbedder();
+      const embedResult = await pdfEmbedder.embedXml(pdfBuffer, xmlString, 'invoice.xml', `${format} Invoice`);
       if (!embedResult.success) {
         throw new EInvoicePDFError('Failed to embed XML in PDF', 'embed', { format });
       }
       return embedResult.data! as Buffer;
     } catch (error) {
-      throw new EInvoicePDFError(`Failed to embed XML in PDF: ${error.message}`, 'embed', { format }, error as Error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new EInvoicePDFError(`Failed to embed XML in PDF: ${errorMessage}`, 'embed', { format }, error as Error);
     }
   }
 
@@ -546,10 +652,11 @@ export class EInvoice implements TInvoice {
         await plugins.fs.writeFile(filePath, xmlString, 'utf-8');
       }
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoiceError(`Failed to save file: ${error.message}`, 'FILE_SAVE_ERROR', { filePath });
+      throw new EInvoiceError(`Failed to save file: ${errorMessage}`, 'FILE_SAVE_ERROR', { filePath });
     }
   }
 
@@ -649,4 +756,20 @@ export class EInvoice implements TInvoice {
   public addItem(item: Partial<TAccountingDocItem>): void {
     this.items.push(this.createItem(item));
   }
-}
+
+  private createValidationError(message: string): ValidationError {
+    const match = message.match(/^([A-Z]{2,}(?:-[A-Z0-9]+)*-\d+):\s*(.+)$/);
+
+    if (match) {
+      return {
+        code: match[1],
+        message: match[2]
+      };
+    }
+
+    return {
+      code: 'VALIDATION_ERROR',
+      message
+    };
+  }
+}

package/ts/formats/base/base.decoder.ts

@@ -37,6 +37,13 @@ export abstract class BaseDecoder {
     return this.xml;
   }
 
+  /**
+   * Gets a parsed XML document when a decoder keeps one around.
+   */
+  public getParsedDocument(): Document | undefined {
+    return undefined;
+  }
+
   /**
    * Parses a CII date string based on format code
    * @param dateStr Date string

package/ts/formats/cii/cii.decoder.ts

@@ -3,6 +3,14 @@ import type { TInvoice, TCreditNote, TDebitNote } from '../../interfaces/common.
 import { CII_NAMESPACES, CIIProfile } from './cii.types.js';
 import { DOMParser, xpath } from '../../plugins.js';
 
+const ciiParser = new DOMParser();
+const ciiNamespaces = {
+  rsm: CII_NAMESPACES.RSM,
+  ram: CII_NAMESPACES.RAM,
+  udt: CII_NAMESPACES.UDT,
+};
+const ciiSelect = xpath.useNamespaces(ciiNamespaces);
+
 /**
  * Base decoder for CII-based invoice formats
  */
@@ -16,22 +24,22 @@ export abstract class CIIBaseDecoder extends BaseDecoder {
     super(xml, skipValidation);
 
     // Parse XML document
-    this.doc = new DOMParser().parseFromString(xml, 'application/xml');
+    this.doc = ciiParser.parseFromString(xml, 'application/xml');
 
     // Set up namespaces for XPath queries
-    this.namespaces = {
-      rsm: CII_NAMESPACES.RSM,
-      ram: CII_NAMESPACES.RAM,
-      udt: CII_NAMESPACES.UDT
-    };
+    this.namespaces = ciiNamespaces;
 
     // Create XPath selector with namespaces
-    this.select = xpath.useNamespaces(this.namespaces);
+    this.select = ciiSelect;
 
     // Detect profile
     this.detectProfile();
   }
 
+  public override getParsedDocument(): Document {
+    return this.doc;
+  }
+
   /**
    * Decodes CII XML into a TInvoice object
    * @returns Promise resolving to a TInvoice object
@@ -93,7 +101,8 @@ export abstract class CIIBaseDecoder extends BaseDecoder {
    * @returns Text value or empty string if not found
    */
   protected getText(xpathExpr: string, context?: Node): string {
-    const node = this.select(xpathExpr, context || this.doc)[0];
+    const result = this.select(xpathExpr, context || this.doc);
+    const node = Array.isArray(result) ? result[0] : null;
     return node ? (node.textContent || '') : '';
   }
 

package/ts/formats/cii/cii.validator.ts

@@ -4,31 +4,35 @@ import type { ValidationResult } from '../../interfaces/common.js';
 import { CII_NAMESPACES, CIIProfile } from './cii.types.js';
 import { DOMParser, xpath } from '../../plugins.js';
 
+const ciiValidatorParser = new DOMParser();
+const ciiValidatorNamespaces = {
+  rsm: CII_NAMESPACES.RSM,
+  ram: CII_NAMESPACES.RAM,
+  udt: CII_NAMESPACES.UDT,
+};
+const ciiValidatorSelect = xpath.useNamespaces(ciiValidatorNamespaces);
+
 /**
  * Base validator for CII-based invoice formats
  */
 export abstract class CIIBaseValidator extends BaseValidator {
-  protected doc: Document;
-  protected namespaces: Record<string, string>;
-  protected select: xpath.XPathSelect;
+  protected doc!: Document;
+  protected namespaces!: Record<string, string>;
+  protected select!: xpath.XPathSelect;
   protected profile: CIIProfile = CIIProfile.EN16931;
 
-  constructor(xml: string) {
+  constructor(xml: string, doc?: Document) {
     super(xml);
 
     try {
-      // Parse XML document
-      this.doc = new DOMParser().parseFromString(xml, 'application/xml');
+      // Reuse an existing parsed document when available.
+      this.doc = doc ?? ciiValidatorParser.parseFromString(xml, 'application/xml');
 
       // Set up namespaces for XPath queries
-      this.namespaces = {
-        rsm: CII_NAMESPACES.RSM,
-        ram: CII_NAMESPACES.RAM,
-        udt: CII_NAMESPACES.UDT
-      };
+      this.namespaces = ciiValidatorNamespaces;
 
       // Create XPath selector with namespaces
-      this.select = xpath.useNamespaces(this.namespaces);
+      this.select = ciiValidatorSelect;
 
       // Detect profile
       this.detectProfile();
@@ -139,7 +143,8 @@ export abstract class CIIBaseValidator extends BaseValidator {
    * @returns Text value or empty string if not found
    */
   protected getText(xpathExpr: string, context?: Node): string {
-    const node = this.select(xpathExpr, context || this.doc)[0];
+    const result = this.select(xpathExpr, context || this.doc);
+    const node = Array.isArray(result) ? result[0] : null;
     return node ? (node.textContent || '') : '';
   }
 

package/ts/formats/cii/facturx/facturx.encoder.ts

@@ -2,6 +2,9 @@ import { CIIBaseEncoder } from '../cii.encoder.js';
 import type { TInvoice, TCreditNote, TDebitNote } from '../../../interfaces/common.js';
 import { FACTURX_PROFILE_IDS } from './facturx.types.js';
 import { DOMParser, XMLSerializer } from '../../../plugins.js';
+import { Decimal } from '../../utils/decimal.js';
+import { DecimalCurrencyCalculator } from '../../utils/currency.calculator.decimal.js';
+import { getCurrencyMinorUnits } from '../../utils/currency.utils.js';
 
 /**
  * Encoder for Factur-X invoice format
@@ -329,42 +332,46 @@ export class FacturXEncoder extends CIIBaseEncoder {
     // Add totals
     const monetarySummationElement = doc.createElement('ram:SpecifiedTradeSettlementHeaderMonetarySummation');
 
-    // Calculate totals
-    let totalNetAmount = 0;
-    let totalTaxAmount = 0;
+    // Calculate totals with decimal arithmetic to avoid floating point drift.
+    const calculator = new DecimalCurrencyCalculator(invoice.currency);
+    const minorUnits = getCurrencyMinorUnits(invoice.currency);
+    let totalNetAmount = Decimal.ZERO;
+    let totalTaxAmount = Decimal.ZERO;
 
     // Calculate from items
     if (invoice.items) {
       for (const item of invoice.items) {
-        const itemNetAmount = item.unitNetPrice * item.unitQuantity;
-        const itemTaxAmount = itemNetAmount * (item.vatPercentage / 100);
+        const itemNetAmount = calculator.calculateLineNet(item.unitQuantity, item.unitNetPrice);
+        const itemTaxAmount = calculator.calculateVAT(itemNetAmount, item.vatPercentage);
 
-        totalNetAmount += itemNetAmount;
-        totalTaxAmount += itemTaxAmount;
+        totalNetAmount = totalNetAmount.add(itemNetAmount);
+        totalTaxAmount = totalTaxAmount.add(itemTaxAmount);
       }
     }
 
-    const totalGrossAmount = totalNetAmount + totalTaxAmount;
+    totalNetAmount = calculator.round(totalNetAmount);
+    totalTaxAmount = calculator.round(totalTaxAmount);
+    const totalGrossAmount = calculator.calculateGrossAmount(totalNetAmount, totalTaxAmount);
 
     // Add line total amount
     const lineTotalElement = doc.createElement('ram:LineTotalAmount');
-    lineTotalElement.textContent = totalNetAmount.toFixed(2);
+    lineTotalElement.textContent = totalNetAmount.toFixed(minorUnits);
     monetarySummationElement.appendChild(lineTotalElement);
 
     // Add tax total amount
     const taxTotalElement = doc.createElement('ram:TaxTotalAmount');
-    taxTotalElement.textContent = totalTaxAmount.toFixed(2);
+    taxTotalElement.textContent = totalTaxAmount.toFixed(minorUnits);
     taxTotalElement.setAttribute('currencyID', invoice.currency);
     monetarySummationElement.appendChild(taxTotalElement);
 
     // Add grand total amount
     const grandTotalElement = doc.createElement('ram:GrandTotalAmount');
-    grandTotalElement.textContent = totalGrossAmount.toFixed(2);
+    grandTotalElement.textContent = totalGrossAmount.toFixed(minorUnits);
     monetarySummationElement.appendChild(grandTotalElement);
 
     // Add due payable amount
     const duePayableElement = doc.createElement('ram:DuePayableAmount');
-    duePayableElement.textContent = totalGrossAmount.toFixed(2);
+    duePayableElement.textContent = totalGrossAmount.toFixed(minorUnits);
     monetarySummationElement.appendChild(duePayableElement);
 
     settlementElement.appendChild(monetarySummationElement);
@@ -377,6 +384,9 @@ export class FacturXEncoder extends CIIBaseEncoder {
    * @param invoice Invoice data
    */
   private addLineItems(doc: Document, transactionElement: Element, invoice: TInvoice): void {
+    const calculator = new DecimalCurrencyCalculator(invoice.currency);
+    const minorUnits = getCurrencyMinorUnits(invoice.currency);
+
     // Add each line item
     if (invoice.items) {
       for (const item of invoice.items) {
@@ -450,12 +460,12 @@ export class FacturXEncoder extends CIIBaseEncoder {
         // Add monetary summation
         const monetarySummationElement = doc.createElement('ram:SpecifiedLineTradeSettlementMonetarySummation');
 
-        // Calculate item total
-        const itemNetAmount = item.unitNetPrice * item.unitQuantity;
+        // Calculate item total with decimal arithmetic and currency rounding.
+        const itemNetAmount = calculator.calculateLineNet(item.unitQuantity, item.unitNetPrice);
 
         // Add line total amount
         const lineTotalElement = doc.createElement('ram:LineTotalAmount');
-        lineTotalElement.textContent = itemNetAmount.toFixed(2);
+        lineTotalElement.textContent = itemNetAmount.toFixed(minorUnits);
         monetarySummationElement.appendChild(lineTotalElement);
 
         settlementElement.appendChild(monetarySummationElement);

package/ts/formats/converters/xml-to-einvoice.converter.ts

@@ -6,17 +6,16 @@
 import * as plugins from '../../plugins.js';
 import type { EInvoice } from '../../einvoice.js';
 import type { TAccountingDocItem } from '@tsclass/tsclass/dist_ts/finance/index.js';
-import { DOMParser } from '@xmldom/xmldom';
 
 /**
  * Converter for XML formats to EInvoice - simplified version
  * This is a basic converter that extracts essential fields for testing
  */
 export class XMLToEInvoiceConverter {
-  private parser: DOMParser;
+  private parser: InstanceType<typeof plugins.DOMParser>;
   
   constructor() {
-    this.parser = new DOMParser();
+    this.parser = new plugins.DOMParser();
   }
   
   /**
@@ -116,7 +115,7 @@ export class XMLToEInvoiceConverter {
       console.warn('Error parsing XML:', error);
     }
     
-    return mockInvoice as EInvoice;
+    return mockInvoice as unknown as EInvoice;
   }
   
   /**
@@ -139,4 +138,4 @@ export class XMLToEInvoiceConverter {
     
     return null;
   }
-}
+}

package/ts/formats/factories/decoder.factory.ts

@@ -16,10 +16,15 @@ export class DecoderFactory {
    * Creates a decoder for the specified XML content
    * @param xml XML content to decode
    * @param skipValidation Whether to skip EN16931 validation
+   * @param formatHint Optional pre-detected format to avoid re-detecting large XML inputs
    * @returns Appropriate decoder instance
    */
-  public static createDecoder(xml: string, skipValidation: boolean = false): BaseDecoder {
-    const format = FormatDetector.detectFormat(xml);
+  public static createDecoder(
+    xml: string,
+    skipValidation: boolean = false,
+    formatHint?: InvoiceFormat,
+  ): BaseDecoder {
+    const format = formatHint ?? FormatDetector.detectFormat(xml);
 
     switch (format) {
       case InvoiceFormat.UBL:

package/ts/formats/factories/validator.factory.ts

@@ -59,28 +59,34 @@ export class ValidatorFactory {
   /**
    * Creates a validator for the specified XML content
    * @param xml XML content to validate
+   * @param formatHint Optional pre-detected format to avoid re-detecting large XML inputs
+   * @param parsedDocument Optional parsed XML document to avoid parsing twice
    * @returns Appropriate validator instance
    */
-  public static createValidator(xml: string): BaseValidator {
+  public static createValidator(
+    xml: string,
+    formatHint?: InvoiceFormat,
+    parsedDocument?: Document,
+  ): BaseValidator {
     try {
-      const format = FormatDetector.detectFormat(xml);
+      const format = formatHint ?? FormatDetector.detectFormat(xml);
 
       switch (format) {
         case InvoiceFormat.UBL:
-          return new EN16931UBLValidator(xml);
+          return new EN16931UBLValidator(xml, parsedDocument);
 
         case InvoiceFormat.XRECHNUNG:
-          return new XRechnungValidator(xml);
+          return new XRechnungValidator(xml, parsedDocument);
 
         case InvoiceFormat.CII:
           // For now, use Factur-X validator for generic CII
-          return new FacturXValidator(xml);
+          return new FacturXValidator(xml, parsedDocument);
 
         case InvoiceFormat.ZUGFERD:
-          return new ZUGFeRDValidator(xml);
+          return new ZUGFeRDValidator(xml, parsedDocument);
 
         case InvoiceFormat.FACTURX:
-          return new FacturXValidator(xml);
+          return new FacturXValidator(xml, parsedDocument);
 
         case InvoiceFormat.FATTURAPA:
           return new FatturaPAValidator(xml);
@@ -131,4 +137,4 @@ class GenericValidator extends BaseValidator {
   protected validateBusinessRules(): boolean {
     return false;
   }
-}
+}