@devlas/dte-sii 2.5.0

package/utils/c14n.js

@@ -0,0 +1,275 @@
+// Copyright (c) 2026 Devlas SpA — https://devlas.cl
+// Licencia MIT. Ver archivo LICENSE para mas detalles.
+/**
+ * Módulo de Canonicalización XML (C14N)
+ * 
+ * Funciones compartidas para serialización canónica de XML
+ * según el estándar W3C Canonical XML Version 1.0.
+ * 
+ * Usado por: DTE.js, Signer.js, LibroBase.js, ConsumoFolio.js
+ */
+
+/**
+ * Escapa atributos XML según C14N
+ * @param {string} value - Valor del atributo
+ * @returns {string} - Valor escapado
+ */
+function escapeAttr(value) {
+  return (value || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/"/g, '&quot;')
+    .replace(/\t/g, '&#x9;')
+    .replace(/\n/g, '&#xA;')
+    .replace(/\r/g, '&#xD;');
+}
+
+/**
+ * Escapa contenido de texto XML según C14N
+ * @param {string} text - Contenido de texto
+ * @returns {string} - Texto escapado
+ */
+function escapeText(text) {
+  return (text || '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/\r/g, '&#xD;');
+}
+
+/**
+ * Corrige entidades en contenido XML (apóstrofes y comillas)
+ * @param {string} xml - XML a procesar
+ * @returns {string} - XML con entidades corregidas
+ */
+function fixEntities(xml) {
+  let out = '';
+  let inContent = false;
+  for (let i = 0; i < xml.length; i++) {
+    const ch = xml[i];
+    if (ch === '>') inContent = true;
+    if (ch === '<') inContent = false;
+    if (inContent && ch === "'") { out += '&apos;'; continue; }
+    if (inContent && ch === '"') { out += '&quot;'; continue; }
+    out += ch;
+  }
+  return out;
+}
+
+/**
+ * Serializa un nodo DOM a XML canónico
+ * @param {Node} node - Nodo DOM a serializar
+ * @param {Map} inheritedNs - Namespaces heredados
+ * @param {Object} options - Opciones
+ * @param {boolean} [options.omitNsFromChildren=false] - No incluir xmlns en hijos
+ * @returns {string} - XML serializado
+ */
+function serializeNode(node, inheritedNs, options = {}) {
+  const { omitNsFromChildren = false } = options;
+
+  // Nodo de texto
+  if (node.nodeType === 3) {
+    return escapeText(node.nodeValue || '');
+  }
+
+  // Solo elementos
+  if (node.nodeType !== 1) return '';
+
+  const tagName = node.tagName || node.nodeName;
+  const currentNs = new Map(inheritedNs);
+  let result = `<${tagName}`;
+
+  // Recoger y ordenar atributos
+  const attrs = [];
+  for (let i = 0; i < node.attributes.length; i++) {
+    const attr = node.attributes[i];
+    
+    // Manejar namespaces
+    if (attr.name.startsWith('xmlns')) {
+      // Si ya está en el contexto heredado con el mismo valor, omitir
+      if (currentNs.get(attr.name) === attr.value) continue;
+      // Opción: omitir xmlns de hijos
+      if (omitNsFromChildren && (attr.name === 'xmlns' || attr.name === 'xmlns:xsi')) continue;
+      currentNs.set(attr.name, attr.value);
+    }
+    
+    attrs.push({ name: attr.name, value: attr.value });
+  }
+
+  // Ordenar: xmlns primero, luego xmlns:*, luego otros alfabéticamente
+  attrs.sort((a, b) => {
+    if (a.name === 'xmlns') return -1;
+    if (b.name === 'xmlns') return 1;
+    const aXmlns = a.name.startsWith('xmlns:');
+    const bXmlns = b.name.startsWith('xmlns:');
+    if (aXmlns && !bXmlns) return -1;
+    if (!aXmlns && bXmlns) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  for (const attr of attrs) {
+    result += ` ${attr.name}="${escapeAttr(attr.value)}"`;
+  }
+  result += '>';
+
+  // Serializar hijos
+  for (let i = 0; i < node.childNodes.length; i++) {
+    result += serializeNode(node.childNodes[i], currentNs, options);
+  }
+
+  result += `</${tagName}>`;
+  return result;
+}
+
+/**
+ * Serializa un elemento con sus hijos para C14N (versión simplificada para Libros)
+ * @param {Element} elemento - Elemento DOM
+ * @param {Object} options - Opciones
+ * @param {boolean} [options.omitRootNs=false] - Omitir xmlns/xmlns:xsi del elemento
+ * @returns {string} - XML serializado
+ */
+function serializeElement(elemento, options = {}) {
+  const { omitRootNs = false } = options;
+  const tagName = elemento.tagName || elemento.nodeName;
+  let result = `<${tagName}`;
+
+  // Recoger y ordenar atributos
+  const attrs = [];
+  for (let i = 0; i < elemento.attributes.length; i++) {
+    const attr = elemento.attributes[i];
+    // Opcionalmente omitir xmlns del root
+    if (omitRootNs && (attr.name === 'xmlns' || attr.name === 'xmlns:xsi')) continue;
+    attrs.push({ name: attr.name, value: attr.value });
+  }
+  
+  attrs.sort((a, b) => a.name.localeCompare(b.name));
+  
+  for (const attr of attrs) {
+    result += ` ${attr.name}="${escapeAttr(attr.value)}"`;
+  }
+  result += '>';
+
+  // Serializar hijos
+  for (let i = 0; i < elemento.childNodes.length; i++) {
+    const child = elemento.childNodes[i];
+    if (child.nodeType === 1) {
+      result += serializeElement(child, { omitRootNs: false });
+    } else if (child.nodeType === 3) {
+      result += escapeText(child.nodeValue);
+    }
+  }
+
+  result += `</${tagName}>`;
+  return result;
+}
+
+/**
+ * Canonicaliza un elemento raíz con namespaces específicos
+ * @param {Element} elemento - Elemento DOM raíz
+ * @param {Object} config - Configuración
+ * @param {string} config.tagName - Nombre del tag raíz
+ * @param {string} config.id - ID del elemento
+ * @param {string} config.xmlns - Namespace por defecto
+ * @param {string} [config.xmlnsXsi] - Namespace XSI (opcional)
+ * @returns {string} - XML canonicalizado
+ */
+function canonicalizeRoot(elemento, config) {
+  const { tagName, id, xmlns, xmlnsXsi } = config;
+  
+  let c14n = `<${tagName}`;
+  if (xmlns) c14n += ` xmlns="${xmlns}"`;
+  if (xmlnsXsi) c14n += ` xmlns:xsi="${xmlnsXsi}"`;
+  if (id) c14n += ` ID="${id}"`;
+  c14n += '>';
+
+  // Serializar hijos (sin heredar xmlns del padre)
+  for (let i = 0; i < elemento.childNodes.length; i++) {
+    const child = elemento.childNodes[i];
+    if (child.nodeType === 1) {
+      c14n += serializeElement(child, { omitRootNs: true });
+    } else if (child.nodeType === 3) {
+      c14n += escapeText(child.nodeValue);
+    }
+  }
+
+  c14n += `</${tagName}>`;
+  return c14n;
+}
+
+// ============================================
+// XML-DSig SignedInfo / Signature Helpers
+// ============================================
+
+/**
+ * Constantes XML-DSig
+ */
+const XMLDSIG_NS = 'http://www.w3.org/2000/09/xmldsig#';
+const C14N_ALGORITHM = 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315';
+const RSA_SHA1_ALGORITHM = 'http://www.w3.org/2000/09/xmldsig#rsa-sha1';
+const SHA1_ALGORITHM = 'http://www.w3.org/2000/09/xmldsig#sha1';
+const ENVELOPED_SIGNATURE = 'http://www.w3.org/2000/09/xmldsig#enveloped-signature';
+const XSI_NS = 'http://www.w3.org/2001/XMLSchema-instance';
+
+/**
+ * Construye el elemento SignedInfo para firma XML-DSig
+ * @param {string} refId - ID del elemento referenciado (con o sin #)
+ * @param {string} digestValue - DigestValue calculado en base64
+ * @param {Object} options - Opciones de construcción
+ * @param {boolean} [options.expandTags=false] - Expandir tags vacíos (para cálculo de firma)
+ * @param {boolean} [options.includeXsi=true] - Incluir xmlns:xsi
+ * @returns {string} - SignedInfo XML
+ */
+function buildSignedInfo(refId, digestValue, options = {}) {
+  const { expandTags = false, includeXsi = true } = options;
+  
+  // Normalizar refId (agregar # si no lo tiene)
+  const uri = refId.startsWith('#') ? refId : `#${refId}`;
+  
+  const xmlns = `xmlns="${XMLDSIG_NS}"`;
+  const xsi = includeXsi ? ` xmlns:xsi="${XSI_NS}"` : '';
+  
+  if (expandTags) {
+    // Tags expandidos: <Tag></Tag> - usado para calcular firma
+    return `<SignedInfo ${xmlns}${xsi}><CanonicalizationMethod Algorithm="${C14N_ALGORITHM}"></CanonicalizationMethod><SignatureMethod Algorithm="${RSA_SHA1_ALGORITHM}"></SignatureMethod><Reference URI="${uri}"><Transforms><Transform Algorithm="${ENVELOPED_SIGNATURE}"></Transform></Transforms><DigestMethod Algorithm="${SHA1_ALGORITHM}"></DigestMethod><DigestValue>${digestValue}</DigestValue></Reference></SignedInfo>`;
+  }
+  
+  // Tags compactos: <Tag/> - usado para guardar en XML
+  return `<SignedInfo ${xmlns}${xsi}><CanonicalizationMethod Algorithm="${C14N_ALGORITHM}"/><SignatureMethod Algorithm="${RSA_SHA1_ALGORITHM}"/><Reference URI="${uri}"><Transforms><Transform Algorithm="${ENVELOPED_SIGNATURE}"/></Transforms><DigestMethod Algorithm="${SHA1_ALGORITHM}"/><DigestValue>${digestValue}</DigestValue></Reference></SignedInfo>`;
+}
+
+/**
+ * Construye la Signature completa XML-DSig
+ * @param {string} signedInfo - SignedInfo XML (formato compacto)
+ * @param {string} signatureValue - Valor de firma en base64
+ * @param {Object} keyInfo - Información de la clave
+ * @param {string} keyInfo.modulus - Modulus RSA en base64
+ * @param {string} keyInfo.exponent - Exponent RSA en base64
+ * @param {string} keyInfo.certificate - Certificado X509 en base64
+ * @returns {string} - Signature XML completa
+ */
+function buildSignature(signedInfo, signatureValue, keyInfo) {
+  const { modulus, exponent, certificate } = keyInfo;
+  
+  return `<Signature xmlns="${XMLDSIG_NS}">${signedInfo}<SignatureValue>\n${signatureValue}</SignatureValue><KeyInfo><KeyValue><RSAKeyValue><Modulus>${modulus}</Modulus><Exponent>${exponent}</Exponent></RSAKeyValue></KeyValue><X509Data><X509Certificate>${certificate}</X509Certificate></X509Data></KeyInfo></Signature>`;
+}
+
+module.exports = {
+  // Escape/Text functions
+  escapeAttr,
+  escapeText,
+  fixEntities,
+  // Serialization
+  serializeNode,
+  serializeElement,
+  canonicalizeRoot,
+  // XML-DSig helpers
+  buildSignedInfo,
+  buildSignature,
+  // Constantes
+  XMLDSIG_NS,
+  C14N_ALGORITHM,
+  RSA_SHA1_ALGORITHM,
+  SHA1_ALGORITHM,
+  ENVELOPED_SIGNATURE,
+  XSI_NS,
+};

package/utils/calculo.js

@@ -0,0 +1,396 @@
+// Copyright (c) 2026 Devlas SpA — https://devlas.cl
+// Licencia MIT. Ver archivo LICENSE para mas detalles.
+/**
+ * Utilidades de Cálculo
+ * 
+ * Funciones centralizadas para cálculo de totales y construcción de detalle DTE.
+ * Estas funciones son reutilizables tanto en certificación como en producción.
+ * 
+ * @module dte-sii/utils/calculo
+ */
+
+// Usar la constante centralizada de constants.js
+const { TASA_IVA } = require('./constants');
+
+// Alias para compatibilidad con código existente
+const TASA_IVA_DEFAULT = TASA_IVA;
+
+// ============================================
+// FORMATEO
+// ============================================
+
+/**
+ * Formatea un número con decimales fijos
+ * @param {number} value - Valor a formatear
+ * @param {number} [decimals=6] - Cantidad de decimales
+ * @returns {string}
+ */
+function formatDecimal(value, decimals = 6) {
+  return Number(value).toFixed(decimals);
+}
+
+/**
+ * Calcula el monto de un ítem con descuento
+ * @param {number} cantidad - Cantidad de unidades
+ * @param {number} precio - Precio unitario
+ * @param {number} [descuentoPct=0] - Porcentaje de descuento
+ * @returns {{ base: number, descuentoMonto: number, montoItem: number }}
+ */
+function calcularMontoItem(cantidad, precio, descuentoPct = 0) {
+  const qty = Number(cantidad || 1);
+  const prc = Number(precio || 0);
+  const base = Math.round(qty * prc);
+  const descuentoMonto = descuentoPct > 0 ? Math.round(base * (descuentoPct / 100)) : 0;
+  const montoItem = base - descuentoMonto;
+  return { base, descuentoMonto, montoItem };
+}
+
+// ============================================
+// CÁLCULO DE TOTALES
+// ============================================
+
+/**
+ * Calcula totales desde un array de items
+ * Función unificada que maneja todos los tipos de DTE
+ * 
+ * @param {Array} items - Array de items con { cantidad, precio, exento?, descuentoPct? }
+ * @param {Object} [options] - Opciones de cálculo
+ * @param {number} [options.tasaIva=19] - Tasa de IVA
+ * @param {number} [options.descuentoGlobalPct=0] - Descuento global en porcentaje
+ * @param {boolean} [options.preciosNetos=true] - Si los precios son netos (sin IVA)
+ * @param {boolean} [options.soloExento=false] - Si el documento es solo exento (ej: tipo 34)
+ * @param {boolean} [options.conRetencion=false] - Si aplica retención total IVA (ej: tipo 46)
+ * @param {number} [options.tipoImpRetencion=15] - Tipo de impuesto para retención
+ * @returns {{ totales: Object, descuentoGlobalMonto: number }}
+ */
+function calcularTotalesDesdeItems(items, optionsOrDescuento = {}) {
+  // Compatibilidad: si el segundo parámetro es número, es descuentoGlobalPct (API antigua)
+  const options = typeof optionsOrDescuento === 'number' || optionsOrDescuento === null
+    ? { descuentoGlobalPct: optionsOrDescuento || 0 }
+    : (optionsOrDescuento || {});
+
+  const {
+    tasaIva = TASA_IVA_DEFAULT,
+    descuentoGlobalPct = 0,
+    preciosNetos = true,
+    soloExento = false,
+    conRetencion = false,
+    tipoImpRetencion = 15,
+  } = options;
+
+  let mntAfecto = 0;
+  let mntExento = 0;
+
+  (items || []).forEach((item) => {
+    const { montoItem } = calcularMontoItem(
+      item.cantidad,
+      item.precio,
+      item.descuentoPct
+    );
+
+    if (item.exento || soloExento) {
+      mntExento += montoItem;
+    } else {
+      mntAfecto += montoItem;
+    }
+  });
+
+  // Aplicar descuento global solo a afectos
+  const descuentoGlobalMonto = descuentoGlobalPct > 0
+    ? Math.round(mntAfecto * (descuentoGlobalPct / 100))
+    : 0;
+
+  // Calcular neto
+  let mntNeto;
+  if (preciosNetos) {
+    mntNeto = Math.max(0, mntAfecto - descuentoGlobalMonto);
+  } else {
+    // Precios incluyen IVA - extraer neto
+    const afectoNeto = mntAfecto - descuentoGlobalMonto;
+    mntNeto = afectoNeto > 0 ? Math.round(afectoNeto / (1 + (tasaIva / 100))) : 0;
+  }
+
+  // Calcular IVA
+  const iva = mntNeto > 0 ? Math.round(mntNeto * (tasaIva / 100)) : 0;
+
+  // Calcular total
+  // Con retención: MntTotal = MntNeto + MntExe (IVA se cancela con retención)
+  // Sin retención: MntTotal = MntNeto + IVA + MntExe
+  const mntTotal = conRetencion
+    ? mntNeto + mntExento
+    : mntNeto + iva + mntExento;
+
+  // Construir objeto de totales en orden SII
+  const totales = {};
+  if (mntNeto > 0) totales.MntNeto = mntNeto;
+  if (mntExento > 0) totales.MntExe = mntExento;
+  if (mntNeto > 0) totales.TasaIVA = tasaIva;
+  if (mntNeto > 0) totales.IVA = iva;
+
+  // Retención de IVA (para Factura de Compra tipo 46)
+  if (conRetencion && iva > 0) {
+    totales.ImptoReten = [{
+      TipoImp: tipoImpRetencion,
+      TasaImp: tasaIva,
+      MontoImp: iva,
+    }];
+  }
+
+  totales.MntTotal = mntTotal;
+
+  return { totales, descuentoGlobalMonto };
+}
+
+/**
+ * Calcula totales desde un array de detalle ya construido
+ * Útil para Guías de Despacho y otros casos donde el detalle ya está armado
+ * 
+ * @param {Array} detalle - Array de líneas de detalle con { MontoItem, IndExe? }
+ * @param {Object} [options] - Opciones de cálculo
+ * @param {number} [options.tasaIva=19] - Tasa de IVA
+ * @param {boolean} [options.preciosNetos=true] - Si los precios son netos
+ * @param {boolean} [options.conRetencion=false] - Si aplica retención de IVA
+ * @param {boolean} [options.sinValores=false] - Si es traslado sin valores (IndTraslado=5)
+ * @returns {Object} Totales para el DTE
+ */
+function calcularTotalesDesdeDetalle(detalle, options = {}) {
+  const {
+    tasaIva = TASA_IVA_DEFAULT,
+    preciosNetos = true,
+    conRetencion = false,
+    sinValores = false,
+  } = options;
+
+  // Traslado sin valores
+  if (sinValores) {
+    return { TasaIVA: tasaIva, MntTotal: 0 };
+  }
+
+  let mntBruto = 0;
+  let mntExento = 0;
+
+  (detalle || []).forEach((det) => {
+    const monto = Number(det.MontoItem || 0);
+    if (det.IndExe === 1) {
+      mntExento += monto;
+    } else {
+      mntBruto += monto;
+    }
+  });
+
+  if (mntBruto === 0 && mntExento === 0) {
+    return { TasaIVA: tasaIva, MntTotal: 0 };
+  }
+
+  const mntNeto = preciosNetos
+    ? mntBruto
+    : (mntBruto > 0 ? Math.round(mntBruto / (1 + (tasaIva / 100))) : 0);
+
+  const iva = mntNeto > 0 ? Math.round(mntNeto * (tasaIva / 100)) : 0;
+
+  const mntTotal = conRetencion
+    ? mntNeto + mntExento
+    : mntNeto + iva + mntExento;
+
+  const totales = {};
+  if (mntNeto > 0) totales.MntNeto = mntNeto;
+  if (mntExento > 0) totales.MntExe = mntExento;
+  if (mntNeto > 0) totales.TasaIVA = tasaIva;
+  if (mntNeto > 0) totales.IVA = iva;
+
+  if (conRetencion && iva > 0) {
+    totales.ImptoReten = [{
+      TipoImp: 15,
+      TasaImp: tasaIva,
+      MontoImp: iva,
+    }];
+  }
+
+  totales.MntTotal = mntTotal;
+
+  return totales;
+}
+
+// ============================================
+// CONSTRUCCIÓN DE DETALLE
+// ============================================
+
+/**
+ * Construye array de detalle para DTE desde items
+ * Función unificada que maneja todos los tipos de documentos
+ * 
+ * @param {Array} items - Items con { nombre, cantidad?, precio?, unidad?, exento?, descuentoPct? }
+ * @param {Object} [options] - Opciones de construcción
+ * @param {boolean} [options.allowIndExe=true] - Agregar IndExe=1 para items exentos (default: true para compatibilidad)
+ * @param {number} [options.codImpAdic=null] - Código de impuesto adicional (ej: 15 para F. Compra)
+ * @param {boolean} [options.forcePriced=false] - Forzar QtyItem/PrcItem aunque precio sea 0
+ * @param {boolean} [options.includeUnidad=false] - Incluir UnmdItem siempre
+ * @param {Function} [options.sanitize=null] - Función para sanitizar texto
+ * @returns {Array} Detalle formateado para DTE
+ */
+function buildDetalle(items, options = {}) {
+  const {
+    allowIndExe = true, // Por defecto true para mantener compatibilidad con código original
+    codImpAdic = null,
+    forcePriced = false,
+    includeUnidad = false,
+    sanitize = (v) => String(v || '').trim(),
+  } = options;
+
+  return (items || []).map((item, idx) => {
+    const qty = Number(item.cantidad ?? 1);
+    const prc = Number(item.precio ?? 0);
+    const descuentoPct = Number(item.descuentoPct || 0);
+    const nombreItem = sanitize(item.nombre);
+
+    const { base, descuentoMonto, montoItem } = calcularMontoItem(qty, prc, descuentoPct);
+
+    // Construir línea de detalle en orden del schema SII
+    const det = {
+      NroLinDet: idx + 1,
+    };
+
+    // IndExe antes de NmbItem
+    if (allowIndExe && item.exento) {
+      det.IndExe = 1;
+    }
+
+    det.NmbItem = nombreItem;
+
+    // QtyItem, UnmdItem, PrcItem
+    if (prc > 0 || forcePriced) {
+      det.QtyItem = qty;
+      if (item.unidad || includeUnidad) {
+        det.UnmdItem = item.unidad || 'UN';
+      }
+      det.PrcItem = prc > 0 ? formatDecimal(Math.max(0.000001, prc)) : prc;
+
+      // Descuento por línea
+      if (descuentoPct > 0) {
+        det.DescuentoPct = descuentoPct;
+        det.DescuentoMonto = descuentoMonto;
+      }
+    }
+
+    // CodImpAdic (antes de MontoItem según schema)
+    if (codImpAdic && !item.exento) {
+      det.CodImpAdic = codImpAdic;
+    }
+
+    det.MontoItem = montoItem;
+
+    return det;
+  });
+}
+
+/**
+ * Construye detalle para Guía de Despacho
+ * Similar a buildDetalle pero con lógica específica para guías
+ * 
+ * @param {Array} items - Items de la guía
+ * @param {Object} [options] - Opciones
+ * @returns {Array} Detalle formateado
+ */
+function buildDetalleGuia(items, options = {}) {
+  const { sanitize = (v) => String(v || '').trim() } = options;
+
+  return (items || []).map((item, idx) => {
+    const qty = Number(item.cantidad ?? 1);
+    const prc = item.precio !== undefined && item.precio !== null ? Number(item.precio) : null;
+    const monto = prc !== null ? Math.round(qty * prc) : (item.monto ?? undefined);
+
+    // Orden XSD: NroLinDet, CdgItem?, IndExe?, NmbItem, DscItem?, QtyRef?, UnmdRef?, PrcRef?, QtyItem?, UnmdItem?, PrcItem?, MontoItem?
+    const det = {
+      NroLinDet: idx + 1,
+    };
+
+    // IndExe va ANTES de NmbItem según XSD
+    if (item.exento) {
+      det.IndExe = 1;
+    }
+
+    det.NmbItem = sanitize(item.nombre);
+    det.QtyItem = qty;
+    det.UnmdItem = item.unidad || 'UN';
+
+    if (prc !== null && prc > 0) {
+      det.PrcItem = prc;
+    }
+
+    if (monto !== undefined) {
+      det.MontoItem = monto;
+    }
+
+    return det;
+  });
+}
+
+/**
+ * Construye detalle para Factura de Compra (tipo 46)
+ * Similar a buildDetalle pero siempre incluye unidad y soporta CodImpAdic
+ * 
+ * @param {Array} items - Items de la factura de compra
+ * @param {Object} [options] - Opciones
+ * @param {number} [options.codImpAdic=15] - Código impuesto adicional (15 = IVA Retenido Total)
+ * @param {Function} [options.sanitize] - Función para sanitizar texto
+ * @returns {Array} Detalle formateado
+ */
+function buildDetalleCompra(items, options = {}) {
+  const { codImpAdic = 15, sanitize = (v) => String(v || '').trim() } = options;
+
+  return buildDetalle(items, {
+    allowIndExe: true,
+    codImpAdic,
+    forcePriced: true,
+    includeUnidad: true,
+    sanitize,
+  });
+}
+
+// ============================================
+// DESCUENTO/RECARGO GLOBAL
+// ============================================
+
+/**
+ * Construye estructura DscRcgGlobal para descuento global
+ * 
+ * @param {number} descuentoPct - Porcentaje de descuento
+ * @param {string} [glosa='DESCUENTO GLOBAL ITEMES AFECTOS'] - Descripción
+ * @returns {Array|null} Estructura DscRcgGlobal o null si no hay descuento
+ */
+function buildDescuentoGlobal(descuentoPct, glosa = 'DESCUENTO GLOBAL ITEMES AFECTOS') {
+  if (!descuentoPct || descuentoPct <= 0) return null;
+
+  return [{
+    NroLinDR: 1,
+    TpoMov: 'D',
+    GlosaDR: glosa,
+    TpoValor: '%',
+    ValorDR: descuentoPct,
+  }];
+}
+
+// ============================================
+// EXPORTS
+// ============================================
+
+module.exports = {
+  // Constantes
+  TASA_IVA_DEFAULT,
+
+  // Formateo
+  formatDecimal,
+  calcularMontoItem,
+
+  // Cálculo de totales
+  calcularTotalesDesdeItems,
+  calcularTotalesDesdeDetalle,
+
+  // Construcción de detalle
+  buildDetalle,
+  buildDetalleGuia,
+  buildDetalleCompra,
+
+  // Descuento global
+  buildDescuentoGlobal,
+};