ghinfe 0.6.0 → 0.6.2

package/src/utils/certificate.utils.js

@@ -1,47 +1,69 @@
-import forge from 'node-forge';
-import { GhinfeError } from '../errors/GhinfeError.js';
-
-/**
- * Carrega certificado A1 (.pfx / .p12) e retorna chave privada + certificado PEM.
- * @param {Buffer|string} pfxBuffer
- * @param {string} password
- * @returns {{ privateKeyPem: string, certificatePem: string, certificate: forge.pki.Certificate }}
- */
-export function loadPfxCertificate(pfxBuffer, password) {
-  try {
-    const buffer = Buffer.isBuffer(pfxBuffer) ? pfxBuffer : Buffer.from(pfxBuffer);
-    const p12Asn1 = forge.asn1.fromDer(buffer.toString('binary'));
-    const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, password);
-
-    const certBags = p12.getBags({ bagType: forge.pki.oids.certBag });
-    const keyBags = p12.getBags({ bagType: forge.pki.oids.pkcs8ShroudedKeyBag });
-
-    const certBag = certBags[forge.pki.oids.certBag]?.[0];
-    const keyBag =
-      keyBags[forge.pki.oids.pkcs8ShroudedKeyBag]?.[0] ??
-      p12.getBags({ bagType: forge.pki.oids.keyBag })[forge.pki.oids.keyBag]?.[0];
-
-    if (!certBag?.cert || !keyBag?.key) {
-      throw new GhinfeError(
-        'Certificado ou chave privada não encontrados no arquivo PFX',
-        'CERT_NOT_FOUND'
-      );
-    }
-
-    const certificate = certBag.cert;
-    const privateKey = keyBag.key;
-
-    return {
-      privateKeyPem: forge.pki.privateKeyToPem(privateKey),
-      certificatePem: forge.pki.certificateToPem(certificate),
-      certificate,
-    };
-  } catch (error) {
-    if (error instanceof GhinfeError) throw error;
-    throw new GhinfeError(
-      'Falha ao carregar certificado PFX. Verifique o arquivo e a senha.',
-      'CERT_LOAD_ERROR',
-      error
-    );
-  }
-}
+import forge from 'node-forge';
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+/**
+ * Monta um PFX em memória a partir de certificado e chave PEM (ex.: cert.pem + key.pem),
+ * para uso nas APIs que recebem { pfx, senha }.
+ * @param {string} certificatePem
+ * @param {string} privateKeyPem Chave sem senha
+ * @param {string} senha Senha do PFX gerado
+ * @returns {Buffer}
+ */
+export function criarPfxDePem(certificatePem, privateKeyPem, senha) {
+  try {
+    const p12 = forge.pkcs12.toPkcs12Asn1(
+      forge.pki.privateKeyFromPem(privateKeyPem),
+      [forge.pki.certificateFromPem(certificatePem)],
+      senha,
+      { algorithm: '3des' }
+    );
+    return Buffer.from(forge.asn1.toDer(p12).getBytes(), 'binary');
+  } catch (error) {
+    throw new GhinfeError('Falha ao converter certificado/chave PEM em PFX', 'CERT_PEM_ERROR', error);
+  }
+}
+
+/**
+ * Carrega certificado A1 (.pfx / .p12) e retorna chave privada + certificado PEM.
+ * @param {Buffer|string} pfxBuffer
+ * @param {string} password
+ * @returns {{ privateKeyPem: string, certificatePem: string, certificate: forge.pki.Certificate }}
+ */
+export function loadPfxCertificate(pfxBuffer, password) {
+  try {
+    const buffer = Buffer.isBuffer(pfxBuffer) ? pfxBuffer : Buffer.from(pfxBuffer);
+    const p12Asn1 = forge.asn1.fromDer(buffer.toString('binary'));
+    const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, password);
+
+    const certBags = p12.getBags({ bagType: forge.pki.oids.certBag });
+    const keyBags = p12.getBags({ bagType: forge.pki.oids.pkcs8ShroudedKeyBag });
+
+    const certBag = certBags[forge.pki.oids.certBag]?.[0];
+    const keyBag =
+      keyBags[forge.pki.oids.pkcs8ShroudedKeyBag]?.[0] ??
+      p12.getBags({ bagType: forge.pki.oids.keyBag })[forge.pki.oids.keyBag]?.[0];
+
+    if (!certBag?.cert || !keyBag?.key) {
+      throw new GhinfeError(
+        'Certificado ou chave privada não encontrados no arquivo PFX',
+        'CERT_NOT_FOUND'
+      );
+    }
+
+    const certificate = certBag.cert;
+    const privateKey = keyBag.key;
+
+    return {
+      privateKeyPem: forge.pki.privateKeyToPem(privateKey),
+      certificatePem: forge.pki.certificateToPem(certificate),
+      certificate,
+    };
+  } catch (error) {
+    if (error instanceof GhinfeError) throw error;
+    throw new GhinfeError(
+      'Falha ao carregar certificado PFX. Verifique o arquivo e a senha.',
+      'CERT_LOAD_ERROR',
+      error
+    );
+  }
+}

package/src/utils/chave.utils.js

@@ -1,117 +1,205 @@
-import { UF_IBGE } from '../constants/sefaz.js';
-import { GhinfeError } from '../errors/GhinfeError.js';
-
-/**
- * Gera código numérico aleatório de 8 dígitos (cNF).
- * @returns {string}
- */
-export function gerarCodigoNumerico() {
-  const valor = Math.floor(Math.random() * 99_999_999) + 1;
-  return String(valor).padStart(8, '0');
-}
-
-/**
- * Calcula dígito verificador da chave NF-e (módulo 11).
- * @param {string} chave43 Primeiros 43 dígitos da chave (sem DV)
- * @returns {string} Dígito verificador (0-9)
- */
-export function calcularDigitoVerificador(chave43) {
-  if (!/^\d{43}$/.test(chave43)) {
-    throw new GhinfeError('Chave deve conter exatamente 43 dígitos para cálculo do DV', 'CHAVE_INVALID_LENGTH');
-  }
-
-  const pesos = [2, 3, 4, 5, 6, 7, 8, 9];
-  let soma = 0;
-  let pesoIndex = 0;
-
-  for (let i = chave43.length - 1; i >= 0; i--) {
-    soma += parseInt(chave43[i], 10) * pesos[pesoIndex];
-    pesoIndex = (pesoIndex + 1) % pesos.length;
-  }
-
-  const resto = soma % 11;
-  return String(resto < 2 ? 0 : 11 - resto);
-}
-
-/**
- * Valida se a chave de acesso possui DV correto.
- * @param {string} chaveAcesso 44 dígitos
- * @returns {boolean}
- */
-export function validarChaveAcesso(chaveAcesso) {
-  const chave = chaveAcesso.replace(/\D/g, '');
-  if (chave.length !== 44) return false;
-  const dvCalculado = calcularDigitoVerificador(chave.substring(0, 43));
-  return dvCalculado === chave[43];
-}
-
-/**
- * Gera chave de acesso NF-e/NFC-e (44 dígitos) conforme layout SEFAZ.
- *
- * Composição: cUF(2) + AAMM(4) + CNPJ(14) + mod(2) + serie(3) + nNF(9) + tpEmis(1) + cNF(8) + cDV(1)
- *
- * @param {{
- *   uf: string,
- *   cnpj: string,
- *   modelo?: string|number,
- *   serie: number,
- *   numero: number,
- *   tipoEmissao?: number,
- *   codigoNumerico?: string,
- *   dataEmissao?: Date,
- * }} params
- * @returns {string}
- */
-export function gerarChaveAcesso(params) {
-  const uf = params.uf?.toUpperCase();
-  const cUF = UF_IBGE[uf];
-
-  if (!cUF) {
-    throw new GhinfeError(`UF inválida: ${params.uf}`, 'UF_INVALIDA');
-  }
-
-  const data = params.dataEmissao ?? new Date();
-  const ano = String(data.getFullYear()).slice(-2);
-  const mes = String(data.getMonth() + 1).padStart(2, '0');
-  const aamm = `${ano}${mes}`;
-
-  const cnpj = params.cnpj.replace(/\D/g, '');
-  if (cnpj.length !== 14) {
-    throw new GhinfeError('CNPJ deve conter 14 dígitos', 'CNPJ_INVALIDO');
-  }
-
-  const modelo = String(params.modelo ?? '55').padStart(2, '0');
-  const serie = String(params.serie).padStart(3, '0');
-  const numero = String(params.numero).padStart(9, '0');
-  const tpEmis = String(params.tipoEmissao ?? 1);
-  const cNF = (params.codigoNumerico ?? gerarCodigoNumerico()).padStart(8, '0');
-
-  const chave43 = `${cUF}${aamm}${cnpj}${modelo}${serie}${numero}${tpEmis}${cNF}`;
-  const cDV = calcularDigitoVerificador(chave43);
-
-  return chave43 + cDV;
-}
-
-/**
- * Extrai campos da chave de acesso para conferência.
- * @param {string} chaveAcesso
- */
-export function parseChaveAcesso(chaveAcesso) {
-  const chave = chaveAcesso.replace(/\D/g, '');
-  if (chave.length !== 44) {
-    throw new GhinfeError('Chave de acesso deve ter 44 dígitos', 'CHAVE_INVALID_LENGTH');
-  }
-
-  return {
-    cUF: chave.substring(0, 2),
-    aamm: chave.substring(2, 6),
-    cnpj: chave.substring(6, 20),
-    modelo: chave.substring(20, 22),
-    serie: parseInt(chave.substring(22, 25), 10),
-    numero: parseInt(chave.substring(25, 34), 10),
-    tipoEmissao: parseInt(chave[34], 10),
-    codigoNumerico: chave.substring(35, 43),
-    digitoVerificador: chave[43],
-    valida: validarChaveAcesso(chave),
-  };
-}
+import { UF_IBGE } from '../constants/sefaz.js';
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+/**
+ * Gera código numérico aleatório de 8 dígitos (cNF).
+ * @returns {string}
+ */
+export function gerarCodigoNumerico() {
+  const valor = Math.floor(Math.random() * 99_999_999) + 1;
+  return String(valor).padStart(8, '0');
+}
+
+/**
+ * Calcula dígito verificador da chave NF-e (módulo 11).
+ * @param {string} chave43 Primeiros 43 dígitos da chave (sem DV)
+ * @returns {string} Dígito verificador (0-9)
+ */
+export function calcularDigitoVerificador(chave43) {
+  if (!/^\d{43}$/.test(chave43)) {
+    throw new GhinfeError('Chave deve conter exatamente 43 dígitos para cálculo do DV', 'CHAVE_INVALID_LENGTH');
+  }
+
+  const pesos = [2, 3, 4, 5, 6, 7, 8, 9];
+  let soma = 0;
+  let pesoIndex = 0;
+
+  for (let i = chave43.length - 1; i >= 0; i--) {
+    soma += parseInt(chave43[i], 10) * pesos[pesoIndex];
+    pesoIndex = (pesoIndex + 1) % pesos.length;
+  }
+
+  const resto = soma % 11;
+  return String(resto < 2 ? 0 : 11 - resto);
+}
+
+/**
+ * Valida se a chave de acesso possui DV correto.
+ * @param {string} chaveAcesso 44 dígitos
+ * @returns {boolean}
+ */
+export function validarChaveAcesso(chaveAcesso) {
+  const chave = chaveAcesso.replace(/\D/g, '');
+  if (chave.length !== 44) return false;
+  const dvCalculado = calcularDigitoVerificador(chave.substring(0, 43));
+  return dvCalculado === chave[43];
+}
+
+/**
+ * Gera chave de acesso NF-e/NFC-e (44 dígitos) conforme layout SEFAZ.
+ *
+ * Composição: cUF(2) + AAMM(4) + CNPJ(14) + mod(2) + serie(3) + nNF(9) + tpEmis(1) + cNF(8) + cDV(1)
+ *
+ * @param {{
+ *   uf: string,
+ *   cnpj: string,
+ *   modelo?: string|number,
+ *   serie: number,
+ *   numero: number,
+ *   tipoEmissao?: number,
+ *   codigoNumerico?: string,
+ *   dataEmissao?: Date,
+ * }} params
+ * @returns {string}
+ */
+export function gerarChaveAcesso(params) {
+  const uf = params.uf?.toUpperCase();
+  const cUF = UF_IBGE[uf];
+
+  if (!cUF) {
+    throw new GhinfeError(`UF inválida: ${params.uf}`, 'UF_INVALIDA');
+  }
+
+  const data = params.dataEmissao ?? new Date();
+  const ano = String(data.getFullYear()).slice(-2);
+  const mes = String(data.getMonth() + 1).padStart(2, '0');
+  const aamm = `${ano}${mes}`;
+
+  const cnpj = params.cnpj.replace(/\D/g, '');
+  if (cnpj.length !== 14) {
+    throw new GhinfeError('CNPJ deve conter 14 dígitos', 'CNPJ_INVALIDO');
+  }
+
+  const modelo = String(params.modelo ?? '55').padStart(2, '0');
+  const serie = String(params.serie).padStart(3, '0');
+  const numero = String(params.numero).padStart(9, '0');
+  const tpEmis = String(params.tipoEmissao ?? 1);
+  const cNF = (params.codigoNumerico ?? gerarCodigoNumerico()).padStart(8, '0');
+
+  const chave43 = `${cUF}${aamm}${cnpj}${modelo}${serie}${numero}${tpEmis}${cNF}`;
+  const cDV = calcularDigitoVerificador(chave43);
+
+  return chave43 + cDV;
+}
+
+/**
+ * Gera código numérico da DC-e (cDC, 6 dígitos).
+ * A SEFAZ rejeita (897) sequências repetidas (000000, 111111...) e cDC igual a nDC.
+ * @param {number} [numero] nDC da declaração
+ * @returns {string}
+ */
+export function gerarCodigoNumericoDCe(numero) {
+  for (;;) {
+    const cDC = String(Math.floor(Math.random() * 1_000_000)).padStart(6, '0');
+    if (/^(\d)\1{5}$/.test(cDC)) continue;
+    if (numero !== undefined && Number(cDC) === Number(numero)) continue;
+    return cDC;
+  }
+}
+
+/**
+ * Gera chave de acesso da DC-e (modelo 99, 44 dígitos).
+ *
+ * Composição: cUF(2) + AAMM(4) + CNPJ(14) + mod(2) + serie(3) + nDC(9) + tpEmis(1)
+ *   + tpEmit(1) + nSiteAutoriz(1) + cDC(6) + cDV(1)
+ *
+ * O CNPJ é o de quem emite/assina: Fisco, Marketplace, Transportadora, ECT
+ * ou o próprio usuário emitente (emissão própria).
+ *
+ * @param {{
+ *   uf: string,
+ *   cnpj: string,
+ *   serie: number,
+ *   numero: number,
+ *   tipoEmitente: number,
+ *   tipoEmissao?: number,
+ *   siteAutorizador?: number,
+ *   codigoNumerico?: string,
+ *   dataEmissao?: Date,
+ * }} params
+ * @returns {string}
+ */
+export function gerarChaveAcessoDCe(params) {
+  const cUF = UF_IBGE[params.uf?.toUpperCase()];
+  if (!cUF) {
+    throw new GhinfeError(`UF inválida: ${params.uf}`, 'UF_INVALIDA');
+  }
+
+  const cnpj = params.cnpj.replace(/\D/g, '');
+  if (cnpj.length !== 14) {
+    throw new GhinfeError('CNPJ deve conter 14 dígitos', 'CNPJ_INVALIDO');
+  }
+
+  const data = params.dataEmissao ?? new Date();
+  const aamm = `${String(data.getFullYear()).slice(-2)}${String(data.getMonth() + 1).padStart(2, '0')}`;
+
+  const serie = String(params.serie).padStart(3, '0');
+  const numero = String(params.numero).padStart(9, '0');
+  const tpEmis = String(params.tipoEmissao ?? 1);
+  const tpEmit = String(params.tipoEmitente);
+  const nSiteAutoriz = String(params.siteAutorizador ?? 0);
+  const cDC = (params.codigoNumerico ?? gerarCodigoNumericoDCe(params.numero)).padStart(6, '0');
+
+  const chave43 = `${cUF}${aamm}${cnpj}99${serie}${numero}${tpEmis}${tpEmit}${nSiteAutoriz}${cDC}`;
+  return chave43 + calcularDigitoVerificador(chave43);
+}
+
+/**
+ * Extrai campos da chave de acesso da DC-e.
+ * @param {string} chaveAcesso
+ */
+export function parseChaveAcessoDCe(chaveAcesso) {
+  const chave = chaveAcesso.replace(/\D/g, '');
+  if (chave.length !== 44) {
+    throw new GhinfeError('Chave de acesso deve ter 44 dígitos', 'CHAVE_INVALID_LENGTH');
+  }
+
+  return {
+    cUF: chave.substring(0, 2),
+    aamm: chave.substring(2, 6),
+    cnpj: chave.substring(6, 20),
+    modelo: chave.substring(20, 22),
+    serie: parseInt(chave.substring(22, 25), 10),
+    numero: parseInt(chave.substring(25, 34), 10),
+    tipoEmissao: parseInt(chave[34], 10),
+    tipoEmitente: parseInt(chave[35], 10),
+    siteAutorizador: parseInt(chave[36], 10),
+    codigoNumerico: chave.substring(37, 43),
+    digitoVerificador: chave[43],
+    valida: validarChaveAcesso(chave),
+  };
+}
+
+/**
+ * Extrai campos da chave de acesso para conferência.
+ * @param {string} chaveAcesso
+ */
+export function parseChaveAcesso(chaveAcesso) {
+  const chave = chaveAcesso.replace(/\D/g, '');
+  if (chave.length !== 44) {
+    throw new GhinfeError('Chave de acesso deve ter 44 dígitos', 'CHAVE_INVALID_LENGTH');
+  }
+
+  return {
+    cUF: chave.substring(0, 2),
+    aamm: chave.substring(2, 6),
+    cnpj: chave.substring(6, 20),
+    modelo: chave.substring(20, 22),
+    serie: parseInt(chave.substring(22, 25), 10),
+    numero: parseInt(chave.substring(25, 34), 10),
+    tipoEmissao: parseInt(chave[34], 10),
+    codigoNumerico: chave.substring(35, 43),
+    digitoVerificador: chave[43],
+    valida: validarChaveAcesso(chave),
+  };
+}

package/src/utils/code128.utils.js

@@ -0,0 +1,67 @@
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+/**
+ * Larguras (barra, espaço, barra, ...) de cada símbolo Code 128, em módulos.
+ * Índice = valor do símbolo; 105 = Start C, 106 = Stop.
+ */
+const PADROES = [
+  '212222', '222122', '222221', '121223', '121322', '131222', '122213', '122312', '132212', '221213',
+  '221312', '231212', '112232', '122132', '122231', '113222', '123122', '123221', '223211', '221132',
+  '221231', '213212', '223112', '312131', '311222', '321122', '321221', '312212', '322112', '322211',
+  '212123', '212321', '232121', '111323', '131123', '131321', '112313', '132113', '132311', '211313',
+  '231113', '231311', '112133', '112331', '132131', '113123', '113321', '133121', '313121', '211331',
+  '231131', '213113', '213311', '213131', '311123', '311321', '331121', '312113', '312311', '332111',
+  '314111', '221411', '431111', '111224', '111422', '121124', '121421', '141122', '141221', '112214',
+  '112412', '122114', '122411', '142112', '142211', '241211', '221114', '413111', '241112', '134111',
+  '111242', '121142', '121241', '114212', '124112', '124211', '411212', '421112', '421211', '212141',
+  '214121', '412121', '111143', '111341', '131141', '114113', '114311', '411113', '411311', '113141',
+  '114131', '311141', '411131', '211412', '211214', '211232', '2331112',
+];
+
+const START_C = 105;
+const STOP = 106;
+
+/**
+ * Codifica dígitos em Code 128 subconjunto C (pares numéricos), com DV módulo 103.
+ * @param {string} digitos Quantidade par de dígitos (ex.: chave de acesso, 44)
+ * @returns {{ simbolos: number[], dv: number, larguras: number[] }}
+ */
+export function codificarCode128C(digitos) {
+  if (!/^\d+$/.test(digitos) || digitos.length % 2 !== 0) {
+    throw new GhinfeError('Code 128C exige quantidade par de dígitos', 'CODE128C_INVALIDO');
+  }
+
+  const dados = digitos.match(/\d{2}/g).map(Number);
+  const soma = dados.reduce((acc, valor, i) => acc + valor * (i + 1), START_C);
+  const dv = soma % 103;
+  const simbolos = [START_C, ...dados, dv, STOP];
+  const larguras = simbolos.flatMap((s) => [...PADROES[s]].map(Number));
+
+  return { simbolos, dv, larguras };
+}
+
+/**
+ * Gera SVG do código de barras Code 128C (barras em unidades de módulo, escalável via CSS).
+ * @param {string} digitos
+ * @param {{ altura?: number, margem?: number }} [opcoes] altura e margem clara em módulos (margem mínima: 10)
+ * @returns {string}
+ */
+export function gerarSvgCode128C(digitos, opcoes = {}) {
+  const altura = opcoes.altura ?? 50;
+  const margem = Math.max(opcoes.margem ?? 10, 10);
+  const { larguras } = codificarCode128C(digitos);
+
+  let x = margem;
+  const barras = [];
+  larguras.forEach((largura, i) => {
+    if (i % 2 === 0) barras.push(`<rect x="${x}" y="0" width="${largura}" height="${altura}"/>`);
+    x += largura;
+  });
+
+  const total = x + margem;
+  return (
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${total} ${altura}" preserveAspectRatio="none" ` +
+    `shape-rendering="crispEdges" role="img" aria-label="${digitos}">` +
+    `<rect width="${total}" height="${altura}" fill="#fff"/><g fill="#000">${barras.join('')}</g></svg>`
+  );
+}

package/src/utils/date.utils.js

@@ -1,26 +1,26 @@
-/**
- * Formata data para padrão SEFAZ: AAAA-MM-DDTHH:mm:ss-03:00
- * @param {Date} [date]
- * @returns {string}
- */
-export function formatSefazDateTime(date = new Date()) {
-  const pad = (n) => String(n).padStart(2, '0');
-  const offset = -date.getTimezoneOffset();
-  const sign = offset >= 0 ? '+' : '-';
-  const abs = Math.abs(offset);
-  const tz = `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
-
-  return (
-    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
-    `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}${tz}`
-  );
-}
-
-/**
- * @param {Date} [date]
- * @returns {string} AAAA-MM-DD
- */
-export function formatSefazDate(date = new Date()) {
-  const pad = (n) => String(n).padStart(2, '0');
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
-}
+/**
+ * Formata data para padrão SEFAZ: AAAA-MM-DDTHH:mm:ss-03:00
+ * @param {Date} [date]
+ * @returns {string}
+ */
+export function formatSefazDateTime(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  const offset = -date.getTimezoneOffset();
+  const sign = offset >= 0 ? '+' : '-';
+  const abs = Math.abs(offset);
+  const tz = `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+
+  return (
+    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+    `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}${tz}`
+  );
+}
+
+/**
+ * @param {Date} [date]
+ * @returns {string} AAAA-MM-DD
+ */
+export function formatSefazDate(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}

package/src/utils/xml.utils.js

@@ -1,44 +1,44 @@
-import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-
-/**
- * @param {string} xml
- * @returns {string}
- */
-export function minifyXml(xml) {
-  return xml.replace(/>\s+</g, '><').trim();
-}
-
-/**
- * @param {string} xml
- * @returns {Document}
- */
-export function parseXml(xml) {
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(xml, 'text/xml');
-  const parseError = doc.getElementsByTagName('parsererror')[0];
-  if (parseError) {
-    throw new Error(`XML inválido: ${parseError.textContent}`);
-  }
-  return doc;
-}
-
-/**
- * @param {Document|Element} node
- * @returns {string}
- */
-export function serializeXml(node) {
-  return new XMLSerializer().serializeToString(node);
-}
-
-/**
- * @param {string} value
- * @returns {string}
- */
-export function escapeXml(value) {
-  return String(value)
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&apos;');
-}
+import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
+
+/**
+ * @param {string} xml
+ * @returns {string}
+ */
+export function minifyXml(xml) {
+  return xml.replace(/>\s+</g, '><').trim();
+}
+
+/**
+ * @param {string} xml
+ * @returns {Document}
+ */
+export function parseXml(xml) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, 'text/xml');
+  const parseError = doc.getElementsByTagName('parsererror')[0];
+  if (parseError) {
+    throw new Error(`XML inválido: ${parseError.textContent}`);
+  }
+  return doc;
+}
+
+/**
+ * @param {Document|Element} node
+ * @returns {string}
+ */
+export function serializeXml(node) {
+  return new XMLSerializer().serializeToString(node);
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}