@ripwords/myinvois-client 0.0.9 → 0.1.0

package/dist/utils/debug/debug-invoice-submission.d.ts

@@ -0,0 +1,152 @@
+import "../../classification-codes-C2X4xW5-.js";
+import "../../country-code-DsI8Mbzx.js";
+import "../../currencies-DKuDflOO.js";
+import "../../e-invoice-C2TxhyrK.js";
+import "../../signatures-C9QPZTQd.js";
+import "../../tax-types-CEpfSh5P.js";
+import "../../1X-C-_KHV-Q.js";
+import "../../2X-DkS1BoE5.js";
+import "../../3X-DFI-4RQQ.js";
+import "../../4X-CIJ2JJ2w.js";
+import "../../5X-COsZHUaQ.js";
+import "../../6X-ClZDKOTC.js";
+import "../../7X-BZyesooz.js";
+import "../../8X-DkuKAkHz.js";
+import "../../9X-BDgifncF.js";
+import "../../AX-D6XHWdrY.js";
+import "../../BX-D_0C8Qbd.js";
+import "../../CX-HH4cSZRX.js";
+import "../../DX-Dx22ax_I.js";
+import "../../EX-BRWh1wFc.js";
+import "../../FX-RmjwAr40.js";
+import "../../GX-CJyo7oDp.js";
+import "../../HX-XALBTdLA.js";
+import "../../IX-6SZ55QKb.js";
+import "../../JX-hQ1XRmLp.js";
+import "../../KX-BNwunEfn.js";
+import "../../LX-CHYX3X3J.js";
+import "../../MX-BPGLWSUz.js";
+import "../../NX-RulN5Ml3.js";
+import "../../OX-DgKVSp7I.js";
+import "../../PX-DA4A2kEv.js";
+import "../../QX-DrFqsMEs.js";
+import "../../RX-Cm7vFcFN.js";
+import "../../SX-CsPPTu-W.js";
+import "../../TX-DCY25MdR.js";
+import "../../UX-DauyagHy.js";
+import "../../VX-DD4scgCe.js";
+import "../../WX-CjkoppdY.js";
+import "../../YX-DUdO8mRC.js";
+import "../../ZX-DwfcSA-D.js";
+import "../../XX-sbsIUOnA.js";
+import "../../unit-types-1bF0KhIp.js";
+import "../../payment-modes-B8dNy3SM.js";
+import "../../0X-C4IRh_fJ.js";
+import "../../1X-Brnls9Jh.js";
+import "../../2X-UdQcQW24.js";
+import "../../3X-DVDyspgb.js";
+import "../../4X-CUR8jlaZ.js";
+import "../../5X-C6db432h.js";
+import "../../6X-C_fFIcJC.js";
+import "../../7X-kot_VccM.js";
+import "../../8X-Df4DOBOe.js";
+import "../../9X-BhBWlgxG.js";
+import "../../msic-codes-bs0lTfSZ.js";
+import { InvoiceV1_1, SigningCredentials } from "../../invoice-1_1-BJVcw-oE.js";
+
+//#region src/utils/debug/debug-invoice-submission.d.ts
+/**
+* Tests both canonicalization algorithms and compares their output
+* This can help determine if the algorithm difference affects signature validation
+* @param xmlDocument - The XML document string to test
+* @returns Object with canonicalization results and comparison
+*/
+declare const testCanonicalizationAlgorithms: (xmlDocument: string) => Promise<{
+  exclusiveC14N: {
+    success: boolean;
+    digest?: string;
+    error?: string;
+  };
+  c14n11Fallback: {
+    success: boolean;
+    digest?: string;
+    error?: string;
+  };
+  areEqual: boolean;
+}>;
+/**
+* Simple validation function that checks basic XML structure requirements
+*/
+declare function validateXMLStructure(xmlString: string): {
+  isValid: boolean;
+  errors: string[];
+  warnings: string[];
+};
+/**
+* Comprehensive debugging function to help identify issues with generated XML
+* This validates the structure against MyInvois requirements and provides detailed feedback
+*/
+declare function debugSignedInvoiceXML(invoiceInfo: InvoiceV1_1, signingCredentials: SigningCredentials): Promise<{
+  success: boolean;
+  signedXML?: string;
+  validationResults: {
+    xmlStructure: {
+      valid: boolean;
+      errors: string[];
+    };
+    signatureElements: {
+      valid: boolean;
+      errors: string[];
+    };
+    digestValues: {
+      valid: boolean;
+      errors: string[];
+    };
+    certificateInfo: {
+      valid: boolean;
+      errors: string[];
+    };
+    canonicalizationTest: any;
+  };
+  stepByStepResults: {
+    step1_template: {
+      success: boolean;
+      error?: string;
+    };
+    step2_transform: {
+      success: boolean;
+      error?: string;
+    };
+    step3_docDigest: {
+      success: boolean;
+      digest?: string;
+      error?: string;
+    };
+    step4_signature: {
+      success: boolean;
+      signature?: string;
+      error?: string;
+    };
+    step5_certDigest: {
+      success: boolean;
+      digest?: string;
+      error?: string;
+    };
+    step6_signedProps: {
+      success: boolean;
+      error?: string;
+    };
+    step7_propsDigest: {
+      success: boolean;
+      digest?: string;
+      error?: string;
+    };
+    step8_finalDoc: {
+      success: boolean;
+      error?: string;
+    };
+  };
+}>;
+//#endregion
+export { debugSignedInvoiceXML, testCanonicalizationAlgorithms, validateXMLStructure };
+//# sourceMappingURL=debug-invoice-submission.d.ts.map

package/dist/utils/debug/debug-invoice-submission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-invoice-submission.d.ts","names":["xmlDocument: string","xmlString: string","invoiceInfo: InvoiceV1_1","signingCredentials: SigningCredentials"],"sources":["../../../src/utils/debug/debug-invoice-submission.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuBa,yDAEV;;;;;;;;;;;;;;;;iBA8Ca,oBAAA;;;;;;;;;iBAqEM,qBAAA,cACP,iCACO,qBACnB;;;;;;;;;;;;;;;;;;;;;;;;;MAxHH,KAAa,CAAA,EAAA,MAAA;IAgDb,CAAA;IAqEA,eAAsB,EAAA;MAAA,OAAA,EAAA,OAAA;MAAA,KACP,CAAA,EAAA,MAAA;IAAA,CAAA;IACO,eACnB,EAAA;MAAA,OAAA,EAAA,OAAA"}

package/dist/utils/debug/debug-invoice-submission.js

@@ -0,0 +1,226 @@
+import { extractCertificateInfo, generateSignedInvoiceXML, generateUBLXMLTemplate, validateKeyPair } from "../../invoice1-1-CHuLpkFz.js";
+import { canonicalizeAndHashDocument, canonicalizeAndHashDocumentWithC14N11Fallback } from "../../canonicalize-DNUrCGad.js";
+import "../../hashCert-Bol7lIh2.js";
+import "../../hashSignedProperties-9vj5wlYR.js";
+import "../../populateFinalDocument-BpLXmgLv.js";
+import "../../populateSignedProperties-BvGN-YZH.js";
+import "../../sign-DzHK7UhR.js";
+import { transformXmlInvoice } from "../../transform-D1q-U6Zj.js";
+import { DOMParserImpl } from "xmldom-ts";
+
+//#region src/utils/debug/debug-invoice-submission.ts
+/**
+* Tests both canonicalization algorithms and compares their output
+* This can help determine if the algorithm difference affects signature validation
+* @param xmlDocument - The XML document string to test
+* @returns Object with canonicalization results and comparison
+*/
+const testCanonicalizationAlgorithms = async (xmlDocument) => {
+	const parser = new DOMParserImpl();
+	const doc = parser.parseFromString(xmlDocument, "application/xml");
+	const results = {
+		exclusiveC14N: { success: false },
+		c14n11Fallback: { success: false },
+		areEqual: false
+	};
+	try {
+		const exclusiveDigest = await canonicalizeAndHashDocument(doc, "http://www.w3.org/2001/10/xml-exc-c14n#");
+		results.exclusiveC14N = {
+			success: true,
+			digest: exclusiveDigest
+		};
+	} catch (error) {
+		results.exclusiveC14N = {
+			success: false,
+			error: error.message
+		};
+	}
+	try {
+		const c14n11Digest = await canonicalizeAndHashDocumentWithC14N11Fallback(doc);
+		results.c14n11Fallback = {
+			success: true,
+			digest: c14n11Digest
+		};
+	} catch (error) {
+		results.c14n11Fallback = {
+			success: false,
+			error: error.message
+		};
+	}
+	if (results.exclusiveC14N.success && results.c14n11Fallback.success) results.areEqual = results.exclusiveC14N.digest === results.c14n11Fallback.digest;
+	return results;
+};
+/**
+* Simple validation function that checks basic XML structure requirements
+*/
+function validateXMLStructure(xmlString) {
+	const errors = [];
+	const warnings = [];
+	try {
+		const parser = new DOMParserImpl();
+		const doc = parser.parseFromString(xmlString, "application/xml");
+		const parserErrors = doc.getElementsByTagName("parsererror");
+		if (parserErrors.length > 0) {
+			errors.push("XML parsing failed");
+			return {
+				isValid: false,
+				errors,
+				warnings
+			};
+		}
+		const requiredElements = [
+			"Invoice",
+			"UBLExtensions",
+			"cbc:ID",
+			"cbc:IssueDate",
+			"cbc:IssueTime",
+			"cbc:InvoiceTypeCode",
+			"ds:Signature",
+			"ds:SignatureValue",
+			"ds:X509Certificate"
+		];
+		for (const element of requiredElements) {
+			const elements = element.includes(":") ? doc.getElementsByTagName(element) : doc.getElementsByTagName(element);
+			if (elements.length === 0) errors.push(`Missing required element: ${element}`);
+		}
+		const expectedNamespaces = [
+			"urn:oasis:names:specification:ubl:schema:xsd:Invoice-2",
+			"urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+			"urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
+		];
+		for (const ns of expectedNamespaces) if (!xmlString.includes(ns)) warnings.push(`Missing namespace declaration: ${ns}`);
+	} catch (error) {
+		errors.push(`XML validation error: ${error.message}`);
+	}
+	return {
+		isValid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+/**
+* Comprehensive debugging function to help identify issues with generated XML
+* This validates the structure against MyInvois requirements and provides detailed feedback
+*/
+async function debugSignedInvoiceXML(invoiceInfo, signingCredentials) {
+	const stepResults = {
+		step1_template: { success: false },
+		step2_transform: { success: false },
+		step3_docDigest: { success: false },
+		step4_signature: { success: false },
+		step5_certDigest: { success: false },
+		step6_signedProps: { success: false },
+		step7_propsDigest: { success: false },
+		step8_finalDoc: { success: false }
+	};
+	const validationResults = {
+		xmlStructure: {
+			valid: false,
+			errors: []
+		},
+		signatureElements: {
+			valid: false,
+			errors: []
+		},
+		digestValues: {
+			valid: false,
+			errors: []
+		},
+		certificateInfo: {
+			valid: false,
+			errors: []
+		},
+		canonicalizationTest: null
+	};
+	let signedXML;
+	try {
+		try {
+			const xmlTemplate = generateUBLXMLTemplate(invoiceInfo);
+			stepResults.step1_template = { success: true };
+			const parser = new DOMParserImpl();
+			const doc = parser.parseFromString(xmlTemplate, "application/xml");
+			const parserErrors = doc.getElementsByTagName("parsererror");
+			if (parserErrors.length > 0) validationResults.xmlStructure.errors.push("XML template parsing failed");
+			else validationResults.xmlStructure.valid = true;
+		} catch (error) {
+			stepResults.step1_template = {
+				success: false,
+				error: error.message
+			};
+			validationResults.xmlStructure.errors.push(`Template generation failed: ${error.message}`);
+		}
+		try {
+			const xmlTemplate = generateUBLXMLTemplate(invoiceInfo);
+			const transformedXml = transformXmlInvoice(xmlTemplate);
+			stepResults.step2_transform = { success: true };
+			if (transformedXml.includes("UBLExtensions")) validationResults.xmlStructure.errors.push("UBLExtensions not properly removed in transformation");
+			if (transformedXml.includes("<cac:Signature>")) validationResults.xmlStructure.errors.push("cac:Signature elements not properly removed in transformation");
+		} catch (error) {
+			stepResults.step2_transform = {
+				success: false,
+				error: error.message
+			};
+		}
+		try {
+			const xmlTemplate = generateUBLXMLTemplate(invoiceInfo);
+			validationResults.canonicalizationTest = await testCanonicalizationAlgorithms(xmlTemplate);
+		} catch (error) {
+			validationResults.canonicalizationTest = { error: error.message };
+		}
+		try {
+			signedXML = await generateSignedInvoiceXML(invoiceInfo, signingCredentials);
+			const parser = new DOMParserImpl();
+			const finalDoc = parser.parseFromString(signedXML, "application/xml");
+			const signatureValue = finalDoc.getElementsByTagName("ds:SignatureValue")[0];
+			const x509Certificate = finalDoc.getElementsByTagName("ds:X509Certificate")[0];
+			const digestValues = finalDoc.getElementsByTagName("ds:DigestValue");
+			if (!signatureValue || !signatureValue.textContent?.trim()) validationResults.signatureElements.errors.push("SignatureValue is empty");
+			if (!x509Certificate || !x509Certificate.textContent?.trim()) validationResults.signatureElements.errors.push("X509Certificate is empty");
+			if (digestValues.length < 2) validationResults.digestValues.errors.push("Missing digest values (expected at least 2)");
+			else {
+				let emptyDigests = 0;
+				for (let i = 0; i < digestValues.length; i++) {
+					const digestElement = digestValues[i];
+					if (!digestElement || !digestElement.textContent?.trim()) emptyDigests++;
+				}
+				if (emptyDigests > 0) validationResults.digestValues.errors.push(`${emptyDigests} digest values are empty`);
+			}
+			try {
+				const certInfo = extractCertificateInfo(signingCredentials.certificatePem);
+				const keyPairValid = validateKeyPair(signingCredentials.certificatePem, signingCredentials.privateKeyPem);
+				if (!keyPairValid) validationResults.certificateInfo.errors.push("Certificate and private key do not match");
+				if (!certInfo.issuerName || !certInfo.serialNumber) validationResults.certificateInfo.errors.push("Certificate info extraction failed");
+				if (validationResults.certificateInfo.errors.length === 0) validationResults.certificateInfo.valid = true;
+			} catch (error) {
+				validationResults.certificateInfo.errors.push(`Certificate validation failed: ${error.message}`);
+			}
+			if (validationResults.signatureElements.errors.length === 0) validationResults.signatureElements.valid = true;
+			if (validationResults.digestValues.errors.length === 0) validationResults.digestValues.valid = true;
+			stepResults.step3_docDigest = { success: true };
+			stepResults.step4_signature = { success: true };
+			stepResults.step5_certDigest = { success: true };
+			stepResults.step6_signedProps = { success: true };
+			stepResults.step7_propsDigest = { success: true };
+			stepResults.step8_finalDoc = { success: true };
+		} catch (error) {
+			console.error("Error during signing process:", error);
+			stepResults.step8_finalDoc = {
+				success: false,
+				error: error.message
+			};
+		}
+	} catch (error) {
+		console.error("Fatal error in debugging:", error);
+	}
+	const allValid = validationResults.xmlStructure.valid && validationResults.signatureElements.valid && validationResults.digestValues.valid && validationResults.certificateInfo.valid;
+	return {
+		success: allValid,
+		signedXML,
+		validationResults,
+		stepByStepResults: stepResults
+	};
+}
+
+//#endregion
+export { debugSignedInvoiceXML, testCanonicalizationAlgorithms, validateXMLStructure };
+//# sourceMappingURL=debug-invoice-submission.js.map

package/dist/utils/debug/debug-invoice-submission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-invoice-submission.js","names":["xmlDocument: string","error: any","xmlString: string","errors: string[]","warnings: string[]","invoiceInfo: InvoiceV1_1","signingCredentials: SigningCredentials","signedXML: string | undefined"],"sources":["../../../src/utils/debug/debug-invoice-submission.ts"],"sourcesContent":["import { DOMParserImpl } from 'xmldom-ts'\nimport {\n  extractCertificateInfo,\n  generateSignedInvoiceXML,\n  generateUBLXMLTemplate,\n  validateKeyPair,\n} from '../invoice1-1'\nimport type {\n  InvoiceV1_1,\n  SigningCredentials,\n} from '../../types/documents/invoice-1_1.d.ts'\nimport { transformXmlInvoice } from '../signature/transform'\nimport {\n  canonicalizeAndHashDocument,\n  canonicalizeAndHashDocumentWithC14N11Fallback,\n} from '../signature/canonicalize'\n\n/**\n * Tests both canonicalization algorithms and compares their output\n * This can help determine if the algorithm difference affects signature validation\n * @param xmlDocument - The XML document string to test\n * @returns Object with canonicalization results and comparison\n */\nexport const testCanonicalizationAlgorithms = async (\n  xmlDocument: string,\n): Promise<{\n  exclusiveC14N: { success: boolean; digest?: string; error?: string }\n  c14n11Fallback: { success: boolean; digest?: string; error?: string }\n  areEqual: boolean\n}> => {\n  const parser = new DOMParserImpl()\n  const doc = parser.parseFromString(xmlDocument, 'application/xml')\n\n  const results = {\n    exclusiveC14N: { success: false } as any,\n    c14n11Fallback: { success: false } as any,\n    areEqual: false,\n  }\n\n  // Test Exclusive C14N\n  try {\n    const exclusiveDigest = await canonicalizeAndHashDocument(\n      doc,\n      'http://www.w3.org/2001/10/xml-exc-c14n#',\n    )\n    results.exclusiveC14N = { success: true, digest: exclusiveDigest }\n  } catch (error: any) {\n    results.exclusiveC14N = { success: false, error: error.message }\n  }\n\n  // Test C14N 1.1 fallback\n  try {\n    const c14n11Digest =\n      await canonicalizeAndHashDocumentWithC14N11Fallback(doc)\n    results.c14n11Fallback = { success: true, digest: c14n11Digest }\n  } catch (error: any) {\n    results.c14n11Fallback = { success: false, error: error.message }\n  }\n\n  // Compare results\n  if (results.exclusiveC14N.success && results.c14n11Fallback.success) {\n    results.areEqual =\n      results.exclusiveC14N.digest === results.c14n11Fallback.digest\n  }\n\n  return results\n}\n\n/**\n * Simple validation function that checks basic XML structure requirements\n */\nexport function validateXMLStructure(xmlString: string): {\n  isValid: boolean\n  errors: string[]\n  warnings: string[]\n} {\n  const errors: string[] = []\n  const warnings: string[] = []\n\n  try {\n    const parser = new DOMParserImpl()\n    const doc = parser.parseFromString(xmlString, 'application/xml')\n\n    // Check for parser errors\n    const parserErrors = doc.getElementsByTagName('parsererror')\n    if (parserErrors.length > 0) {\n      errors.push('XML parsing failed')\n      return { isValid: false, errors, warnings }\n    }\n\n    // Check required elements\n    const requiredElements = [\n      'Invoice',\n      'UBLExtensions',\n      'cbc:ID',\n      'cbc:IssueDate',\n      'cbc:IssueTime',\n      'cbc:InvoiceTypeCode',\n      'ds:Signature',\n      'ds:SignatureValue',\n      'ds:X509Certificate',\n    ]\n\n    for (const element of requiredElements) {\n      const elements = element.includes(':')\n        ? doc.getElementsByTagName(element)\n        : doc.getElementsByTagName(element)\n\n      if (elements.length === 0) {\n        errors.push(`Missing required element: ${element}`)\n      }\n    }\n\n    // Check namespace declarations\n    const expectedNamespaces = [\n      'urn:oasis:names:specification:ubl:schema:xsd:Invoice-2',\n      'urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2',\n      'urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2',\n    ]\n\n    for (const ns of expectedNamespaces) {\n      if (!xmlString.includes(ns)) {\n        warnings.push(`Missing namespace declaration: ${ns}`)\n      }\n    }\n  } catch (error: any) {\n    errors.push(`XML validation error: ${error.message}`)\n  }\n\n  return {\n    isValid: errors.length === 0,\n    errors,\n    warnings,\n  }\n}\n\n/**\n * Comprehensive debugging function to help identify issues with generated XML\n * This validates the structure against MyInvois requirements and provides detailed feedback\n */\nexport async function debugSignedInvoiceXML(\n  invoiceInfo: InvoiceV1_1,\n  signingCredentials: SigningCredentials,\n): Promise<{\n  success: boolean\n  signedXML?: string\n  validationResults: {\n    xmlStructure: { valid: boolean; errors: string[] }\n    signatureElements: { valid: boolean; errors: string[] }\n    digestValues: { valid: boolean; errors: string[] }\n    certificateInfo: { valid: boolean; errors: string[] }\n    canonicalizationTest: any\n  }\n  stepByStepResults: {\n    step1_template: { success: boolean; error?: string }\n    step2_transform: { success: boolean; error?: string }\n    step3_docDigest: { success: boolean; digest?: string; error?: string }\n    step4_signature: { success: boolean; signature?: string; error?: string }\n    step5_certDigest: { success: boolean; digest?: string; error?: string }\n    step6_signedProps: { success: boolean; error?: string }\n    step7_propsDigest: { success: boolean; digest?: string; error?: string }\n    step8_finalDoc: { success: boolean; error?: string }\n  }\n}> {\n  const stepResults = {\n    step1_template: { success: false } as any,\n    step2_transform: { success: false } as any,\n    step3_docDigest: { success: false } as any,\n    step4_signature: { success: false } as any,\n    step5_certDigest: { success: false } as any,\n    step6_signedProps: { success: false } as any,\n    step7_propsDigest: { success: false } as any,\n    step8_finalDoc: { success: false } as any,\n  }\n\n  const validationResults = {\n    xmlStructure: { valid: false, errors: [] as string[] },\n    signatureElements: { valid: false, errors: [] as string[] },\n    digestValues: { valid: false, errors: [] as string[] },\n    certificateInfo: { valid: false, errors: [] as string[] },\n    canonicalizationTest: null as any,\n  }\n\n  let signedXML: string | undefined\n\n  try {\n    // Step 1: Generate template\n    try {\n      const xmlTemplate = generateUBLXMLTemplate(invoiceInfo)\n      stepResults.step1_template = { success: true }\n\n      // Validate XML structure\n      const parser = new DOMParserImpl()\n      const doc = parser.parseFromString(xmlTemplate, 'application/xml')\n      const parserErrors = doc.getElementsByTagName('parsererror')\n      if (parserErrors.length > 0) {\n        validationResults.xmlStructure.errors.push(\n          'XML template parsing failed',\n        )\n      } else {\n        validationResults.xmlStructure.valid = true\n      }\n    } catch (error: any) {\n      stepResults.step1_template = { success: false, error: error.message }\n      validationResults.xmlStructure.errors.push(\n        `Template generation failed: ${error.message}`,\n      )\n    }\n\n    // Step 2: Transform\n    try {\n      const xmlTemplate = generateUBLXMLTemplate(invoiceInfo)\n      const transformedXml = transformXmlInvoice(xmlTemplate)\n      stepResults.step2_transform = { success: true }\n\n      // Check if transformation worked correctly\n      if (transformedXml.includes('UBLExtensions')) {\n        validationResults.xmlStructure.errors.push(\n          'UBLExtensions not properly removed in transformation',\n        )\n      }\n      if (transformedXml.includes('<cac:Signature>')) {\n        validationResults.xmlStructure.errors.push(\n          'cac:Signature elements not properly removed in transformation',\n        )\n      }\n    } catch (error: any) {\n      stepResults.step2_transform = { success: false, error: error.message }\n    }\n\n    // Test canonicalization\n    try {\n      const xmlTemplate = generateUBLXMLTemplate(invoiceInfo)\n      validationResults.canonicalizationTest =\n        await testCanonicalizationAlgorithms(xmlTemplate)\n    } catch (error: any) {\n      validationResults.canonicalizationTest = { error: error.message }\n    }\n\n    // Continue with full signing process\n    try {\n      signedXML = await generateSignedInvoiceXML(\n        invoiceInfo,\n        signingCredentials,\n      )\n\n      // Parse the final signed XML for validation\n      const parser = new DOMParserImpl()\n      const finalDoc = parser.parseFromString(signedXML, 'application/xml')\n\n      // Check signature elements are populated\n      const signatureValue =\n        finalDoc.getElementsByTagName('ds:SignatureValue')[0]\n      const x509Certificate =\n        finalDoc.getElementsByTagName('ds:X509Certificate')[0]\n      const digestValues = finalDoc.getElementsByTagName('ds:DigestValue')\n\n      if (!signatureValue || !signatureValue.textContent?.trim()) {\n        validationResults.signatureElements.errors.push(\n          'SignatureValue is empty',\n        )\n      }\n\n      if (!x509Certificate || !x509Certificate.textContent?.trim()) {\n        validationResults.signatureElements.errors.push(\n          'X509Certificate is empty',\n        )\n      }\n\n      if (digestValues.length < 2) {\n        validationResults.digestValues.errors.push(\n          'Missing digest values (expected at least 2)',\n        )\n      } else {\n        let emptyDigests = 0\n        for (let i = 0; i < digestValues.length; i++) {\n          const digestElement = digestValues[i]\n          if (!digestElement || !digestElement.textContent?.trim()) {\n            emptyDigests++\n          }\n        }\n        if (emptyDigests > 0) {\n          validationResults.digestValues.errors.push(\n            `${emptyDigests} digest values are empty`,\n          )\n        }\n      }\n\n      // Validate certificate info\n      try {\n        const certInfo = extractCertificateInfo(\n          signingCredentials.certificatePem,\n        )\n        const keyPairValid = validateKeyPair(\n          signingCredentials.certificatePem,\n          signingCredentials.privateKeyPem,\n        )\n\n        if (!keyPairValid) {\n          validationResults.certificateInfo.errors.push(\n            'Certificate and private key do not match',\n          )\n        }\n\n        if (!certInfo.issuerName || !certInfo.serialNumber) {\n          validationResults.certificateInfo.errors.push(\n            'Certificate info extraction failed',\n          )\n        }\n\n        if (validationResults.certificateInfo.errors.length === 0) {\n          validationResults.certificateInfo.valid = true\n        }\n      } catch (error: any) {\n        validationResults.certificateInfo.errors.push(\n          `Certificate validation failed: ${error.message}`,\n        )\n      }\n\n      // Set validation flags\n      if (validationResults.signatureElements.errors.length === 0) {\n        validationResults.signatureElements.valid = true\n      }\n      if (validationResults.digestValues.errors.length === 0) {\n        validationResults.digestValues.valid = true\n      }\n\n      // Mark individual steps as successful if we got here\n      stepResults.step3_docDigest = { success: true }\n      stepResults.step4_signature = { success: true }\n      stepResults.step5_certDigest = { success: true }\n      stepResults.step6_signedProps = { success: true }\n      stepResults.step7_propsDigest = { success: true }\n      stepResults.step8_finalDoc = { success: true }\n    } catch (error: any) {\n      console.error('Error during signing process:', error)\n      stepResults.step8_finalDoc = { success: false, error: error.message }\n    }\n  } catch (error: any) {\n    console.error('Fatal error in debugging:', error)\n  }\n\n  const allValid =\n    validationResults.xmlStructure.valid &&\n    validationResults.signatureElements.valid &&\n    validationResults.digestValues.valid &&\n    validationResults.certificateInfo.valid\n\n  return {\n    success: allValid,\n    signedXML,\n    validationResults,\n    stepByStepResults: stepResults,\n  }\n}\n"],"mappings":"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"}

package/dist/utils/getBaseUrl.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/getBaseUrl.d.ts
+declare const getBaseUrl: (environment: "sandbox" | "production") => string;
+//#endregion
+export { getBaseUrl };
+//# sourceMappingURL=getBaseUrl.d.ts.map

package/dist/utils/getBaseUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBaseUrl.d.ts","names":["environment: 'sandbox' | 'production'"],"sources":["../../src/utils/getBaseUrl.ts"],"sourcesContent":[],"mappings":";cAAa"}

package/dist/utils/getBaseUrl.js

@@ -0,0 +1,3 @@
+import { getBaseUrl } from "../getBaseUrl-Dx6RDC8I.js";
+
+export { getBaseUrl };

package/dist/utils/invoice1-1.d.ts

@@ -0,0 +1,117 @@
+import "../classification-codes-C2X4xW5-.js";
+import "../country-code-DsI8Mbzx.js";
+import "../currencies-DKuDflOO.js";
+import "../e-invoice-C2TxhyrK.js";
+import "../signatures-C9QPZTQd.js";
+import "../tax-types-CEpfSh5P.js";
+import "../1X-C-_KHV-Q.js";
+import "../2X-DkS1BoE5.js";
+import "../3X-DFI-4RQQ.js";
+import "../4X-CIJ2JJ2w.js";
+import "../5X-COsZHUaQ.js";
+import "../6X-ClZDKOTC.js";
+import "../7X-BZyesooz.js";
+import "../8X-DkuKAkHz.js";
+import "../9X-BDgifncF.js";
+import "../AX-D6XHWdrY.js";
+import "../BX-D_0C8Qbd.js";
+import "../CX-HH4cSZRX.js";
+import "../DX-Dx22ax_I.js";
+import "../EX-BRWh1wFc.js";
+import "../FX-RmjwAr40.js";
+import "../GX-CJyo7oDp.js";
+import "../HX-XALBTdLA.js";
+import "../IX-6SZ55QKb.js";
+import "../JX-hQ1XRmLp.js";
+import "../KX-BNwunEfn.js";
+import "../LX-CHYX3X3J.js";
+import "../MX-BPGLWSUz.js";
+import "../NX-RulN5Ml3.js";
+import "../OX-DgKVSp7I.js";
+import "../PX-DA4A2kEv.js";
+import "../QX-DrFqsMEs.js";
+import "../RX-Cm7vFcFN.js";
+import "../SX-CsPPTu-W.js";
+import "../TX-DCY25MdR.js";
+import "../UX-DauyagHy.js";
+import "../VX-DD4scgCe.js";
+import "../WX-CjkoppdY.js";
+import "../YX-DUdO8mRC.js";
+import "../ZX-DwfcSA-D.js";
+import "../XX-sbsIUOnA.js";
+import "../unit-types-1bF0KhIp.js";
+import "../payment-modes-B8dNy3SM.js";
+import "../0X-C4IRh_fJ.js";
+import "../1X-Brnls9Jh.js";
+import "../2X-UdQcQW24.js";
+import "../3X-DVDyspgb.js";
+import "../4X-CUR8jlaZ.js";
+import "../5X-C6db432h.js";
+import "../6X-C_fFIcJC.js";
+import "../7X-kot_VccM.js";
+import "../8X-Df4DOBOe.js";
+import "../9X-BhBWlgxG.js";
+import "../msic-codes-bs0lTfSZ.js";
+import { InvoiceV1_1, SigningCredentials } from "../invoice-1_1-BJVcw-oE.js";
+
+//#region src/utils/invoice1-1.d.ts
+/**
+* Generates a document hash for submission (separate from signature DocDigest)
+* This is the SHA256 hash required by the Submit Documents API
+*
+* OFFICIAL MyInvois FAQ: "The XML/JSON document is hashed using SHA-256 to create the documentHash value"
+* CRITICAL: Must hash the SAME document that gets encoded for submission (minified XML)
+* Source: https://sdk.myinvois.hasil.gov.my/faq/#how-to-hash-the-documenthash-value-and-encode-the-document-value
+*/
+declare const generateDocumentHash: (xmlDocument: string) => string;
+/**
+* Encodes the XML document to base64 for submission
+* Includes minification as recommended by MyInvois documentation
+*/
+declare const encodeDocumentForSubmission: (xmlDocument: string) => string;
+/**
+* Utility functions for extracting certificate information
+*/
+/**
+* Extracts certificate information from a PEM certificate file
+* @param certificatePem - The certificate in PEM format
+* @returns Object containing issuer name and serial number
+*/
+declare const extractCertificateInfo: (certificatePem: string) => {
+  issuerName: string;
+  serialNumber: string;
+};
+/**
+* Validates that certificate and private key match
+* @param certificatePem - The certificate in PEM format
+* @param privateKeyPem - The private key in PEM format
+* @returns boolean indicating if they match
+*/
+declare const validateKeyPair: (certificatePem: string, privateKeyPem: string) => boolean;
+/**
+* Helper function to create SigningCredentials from certificate and private key files
+* @param certificatePem - The certificate in PEM format
+* @param privateKeyPem - The private key in PEM format
+* @returns Complete SigningCredentials object
+*/
+declare function createSigningCredentials(certificatePem: string, privateKeyPem: string): SigningCredentials;
+/**
+* Generates the UBL XML template with complete signature structure
+*/
+declare function generateUBLXMLTemplate(invoiceInfo: InvoiceV1_1): string;
+/**
+* Generates a signed UBL XML invoice document following MyInvois specifications.
+*
+* @param invoiceInfo - The invoice data structure
+* @param signingCredentials - Digital signature credentials
+* @returns Promise<string> - The complete signed XML document ready for submission
+*/
+declare const generateSignedInvoiceXML: (invoiceInfo: InvoiceV1_1, signingCredentials: SigningCredentials) => Promise<string>;
+/**
+* Generates a document hash for submission using the same method as signature creation
+* This ensures consistency with MyInvois validation requirements
+*/
+declare const generateDocumentHashForSubmission: (xmlDocument: string) => Promise<string>;
+//#endregion
+export { createSigningCredentials, encodeDocumentForSubmission, extractCertificateInfo, generateDocumentHash, generateDocumentHashForSubmission, generateSignedInvoiceXML, generateUBLXMLTemplate, validateKeyPair };
+//# sourceMappingURL=invoice1-1.d.ts.map

package/dist/utils/invoice1-1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoice1-1.d.ts","names":["xmlDocument: string","certificatePem: string","privateKeyPem: string","invoiceInfo: InvoiceV1_1","signingCredentials: SigningCredentials"],"sources":["../../src/utils/invoice1-1.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ta;;;;;cA2CA;;;;;;;;;cAcA;;;;;;;;;;cAoCA;;;;;;;iBA+BG,wBAAA,iDAGb;;;;iBAoBa,sBAAA,cAAoC;;;;;;;;cAgHvC,wCACE,iCACO,uBACnB;;;;AAtQH;AA2Ca,cAuRA,iCAvR+BA,EAAAA,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,GAyRzC,OAzRyCA,CAAAA,MAAAA,CAAAA"}

package/dist/utils/invoice1-1.js

@@ -0,0 +1,10 @@
+import { createSigningCredentials, encodeDocumentForSubmission, extractCertificateInfo, generateDocumentHash, generateDocumentHashForSubmission, generateSignedInvoiceXML, generateUBLXMLTemplate, validateKeyPair } from "../invoice1-1-CHuLpkFz.js";
+import "../canonicalize-DNUrCGad.js";
+import "../hashCert-Bol7lIh2.js";
+import "../hashSignedProperties-9vj5wlYR.js";
+import "../populateFinalDocument-BpLXmgLv.js";
+import "../populateSignedProperties-BvGN-YZH.js";
+import "../sign-DzHK7UhR.js";
+import "../transform-D1q-U6Zj.js";
+
+export { createSigningCredentials, encodeDocumentForSubmission, extractCertificateInfo, generateDocumentHash, generateDocumentHashForSubmission, generateSignedInvoiceXML, generateUBLXMLTemplate, validateKeyPair };

package/dist/utils/signature/canonicalize.d.ts

@@ -0,0 +1,26 @@
+//#region src/utils/signature/canonicalize.d.ts
+/**
+* Canonicalizes the XML document using the best available canonicalization algorithm,
+* hashes it using SHA-256, and returns the Base64 encoded digest.
+*
+* Corresponds to Step 3 in the MyInvois Signature Creation guide:
+* https://sdk.myinvois.hasil.gov.my/signature-creation/#step-3-canonicalize-the-document-and-generate-the-document-hash-digest
+*
+* Note: MyInvois documentation specifies C14N 1.1, but due to limited Node.js library support,
+* this implementation uses Exclusive C14N which is widely supported and should be compatible
+* in most cases. If signature validation fails, this may need to be updated.
+*
+* @param doc The XML Document object (from xmldom-ts) after transformations (Step 2).
+* @param algorithm Optional canonicalization algorithm URI. Defaults to Exclusive C14N.
+* @returns A Promise resolving to the Base64 encoded SHA-256 hash (DocDigest).
+* @throws {Error} If canonicalization or hashing fails.
+*/
+declare function canonicalizeAndHashDocument(doc: Document, algorithm?: string): Promise<string>;
+/**
+* Attempts to use C14N 1.1 if available, otherwise falls back to Exclusive C14N.
+* This function provides a way to try the MyInvois-specified algorithm first.
+*/
+declare function canonicalizeAndHashDocumentWithC14N11Fallback(doc: Document): Promise<string>;
+//#endregion
+export { canonicalizeAndHashDocument, canonicalizeAndHashDocumentWithC14N11Fallback };
+//# sourceMappingURL=canonicalize.d.ts.map

package/dist/utils/signature/canonicalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalize.d.ts","names":["doc: Document","algorithm: string"],"sources":["../../../src/utils/signature/canonicalize.ts"],"sourcesContent":[],"mappings":";;AAmBA;;;;AAGG;AAgEH;;;;AAEG;;;;;;iBArEa,2BAAA,MACT,+BAEJ;;;;;iBAgEmB,6CAAA,MACf,WACJ"}

package/dist/utils/signature/canonicalize.js

@@ -0,0 +1,3 @@
+import { canonicalizeAndHashDocument, canonicalizeAndHashDocumentWithC14N11Fallback } from "../../canonicalize-DNUrCGad.js";
+
+export { canonicalizeAndHashDocument, canonicalizeAndHashDocumentWithC14N11Fallback };

package/dist/utils/signature/hashCert.d.ts

@@ -0,0 +1,15 @@
+//#region src/utils/signature/hashCert.d.ts
+/**
+* Hashes the signing certificate using SHA-256 and encodes the hash in Base64.
+*
+* Corresponds to Step 5 in the MyInvois Signature Creation guide:
+* https://sdk.myinvois.hasil.gov.my/signature-creation/#step-5-generate-the-certificate-hash
+*
+* @param certificatePem The signing certificate in PEM format (string).
+* @returns The Base64 encoded SHA-256 hash of the certificate (CertDigest).
+* @throws {Error} If hashing fails or PEM is invalid.
+*/
+declare function hashCertificate(certificatePem: string): string;
+//#endregion
+export { hashCertificate };
+//# sourceMappingURL=hashCert.d.ts.map

package/dist/utils/signature/hashCert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashCert.d.ts","names":["certificatePem: string"],"sources":["../../../src/utils/signature/hashCert.ts"],"sourcesContent":[],"mappings":";;AAgFA;;;;;;;;;iBAAgB,eAAA"}

package/dist/utils/signature/hashCert.js

@@ -0,0 +1,3 @@
+import { hashCertificate } from "../../hashCert-Bol7lIh2.js";
+
+export { hashCertificate };

package/dist/utils/signature/hashSignedProperties.d.ts

@@ -0,0 +1,25 @@
+//#region src/utils/signature/hashSignedProperties.d.ts
+/**
+* Selects the SignedProperties element, canonicalizes it using the best available
+* canonicalization algorithm, hashes it using SHA-256, and returns the Base64 encoded digest.
+*
+* Corresponds to Step 7 in the MyInvois Signature Creation guide:
+* https://sdk.myinvois.hasil.gov.my/signature-creation/#step-7-generate-signed-properties-hash
+*
+* Note: MyInvois documentation specifies C14N 1.1, but due to limited Node.js library support,
+* this implementation uses Exclusive C14N which is widely supported and should be compatible
+* in most cases. If signature validation fails, this may need to be updated.
+*
+* @param doc The XML Document object (from xmldom-ts) after SignedProperties population (Step 6).
+* @param algorithm Optional canonicalization algorithm URI. Defaults to Exclusive C14N.
+* @returns A Promise resolving to the Base64 encoded SHA-256 hash (PropsDigest).
+* @throws {Error} If the SignedProperties element cannot be found or canonicalization/hashing fails.
+*/
+declare function hashSignedProperties(doc: Document, algorithm?: string): Promise<string>;
+/**
+* Attempts to use C14N 1.1 for SignedProperties if available, otherwise falls back to Exclusive C14N.
+*/
+declare function hashSignedPropertiesWithC14N11Fallback(doc: Document): Promise<string>;
+//#endregion
+export { hashSignedProperties, hashSignedPropertiesWithC14N11Fallback };
+//# sourceMappingURL=hashSignedProperties.d.ts.map

package/dist/utils/signature/hashSignedProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashSignedProperties.d.ts","names":["doc: Document","algorithm: string"],"sources":["../../../src/utils/signature/hashSignedProperties.ts"],"sourcesContent":[],"mappings":";;AAoBA;;;;AAGG;AA+GH;;;;AAEG;;;;;;iBApHa,oBAAA,MACT,+BAEJ;;;;iBA+GmB,sCAAA,MACf,WACJ"}