node-opcua-crypto 4.16.1 → 5.0.0

package/dist/{chunk-MGQCHN54.mjs → chunk-BIS3W2GR.mjs}

@@ -1,10 +1,4 @@
 var __defProp = Object.defineProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,6 +11,27 @@ var getFilename = () => fileURLToPath(import.meta.url);
 var getDirname = () => path.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
+// source/common.ts
+import __crypto from "crypto";
+var KeyObjectOrig = __crypto.KeyObject;
+var { createPrivateKey: createPrivateKeyFromNodeJSCrypto } = __crypto;
+function isKeyObject(mayBeKeyObject) {
+  if (KeyObjectOrig) {
+    return mayBeKeyObject instanceof KeyObjectOrig;
+  }
+  return typeof mayBeKeyObject === "object" && typeof mayBeKeyObject.type === "string";
+}
+var CertificatePurpose = /* @__PURE__ */ ((CertificatePurpose2) => {
+  CertificatePurpose2[CertificatePurpose2["NotSpecified"] = 0] = "NotSpecified";
+  CertificatePurpose2[CertificatePurpose2["ForCertificateAuthority"] = 1] = "ForCertificateAuthority";
+  CertificatePurpose2[CertificatePurpose2["ForApplication"] = 2] = "ForApplication";
+  CertificatePurpose2[CertificatePurpose2["ForUserAuthentication"] = 3] = "ForUserAuthentication";
+  return CertificatePurpose2;
+})(CertificatePurpose || {});
+
+// source/crypto_explore_certificate.ts
+import assert4 from "assert";
+
 // source/asn1.ts
 import assert from "assert";
 
@@ -354,7 +369,7 @@ var TagType = /* @__PURE__ */ ((TagType2) => {
 function readTag(buf, pos) {
   const start = pos;
   if (buf.length <= pos) {
-    throw new Error("Invalid position : buf.length=" + buf.length + " pos =" + pos);
+    throw new Error(`Invalid position : buf.length=${buf.length} pos=${pos}`);
   }
   const tag = buf.readUInt8(pos);
   pos += 1;
@@ -383,7 +398,8 @@ function readStruct(buf, blockInfo) {
   return blocks;
 }
 function parseBitString(buffer, start, end, maxLength) {
-  const unusedBit = buffer.readUInt8(start), lenBit = (end - start - 1 << 3) - unusedBit, intro = "(" + lenBit + " bit)\n";
+  const unusedBit = buffer.readUInt8(start), lenBit = (end - start - 1 << 3) - unusedBit, intro = `(${lenBit} bit)
+`;
   let s = "", skip = unusedBit;
   for (let i = end - 1; i > start; --i) {
     const b = buffer.readUInt8(i);
@@ -409,7 +425,7 @@ function readBitString(buffer, block) {
 function formatBuffer2DigitHexWithColum(buffer) {
   const value = [];
   for (let i = 0; i < buffer.length; i++) {
-    value.push(("00" + buffer.readUInt8(i).toString(16)).substr(-2, 2));
+    value.push(`00${buffer.readUInt8(i).toString(16)}`.substr(-2, 2));
   }
   return value.join(":").toUpperCase().replace(/^(00:)*/, "");
 }
@@ -446,9 +462,9 @@ function parseOID(buffer, start, end) {
     if (!(v & 128)) {
       if (s === "") {
         const m = n < 80 ? n < 40 ? 0 : 1 : 2;
-        s = m + "." + (n - m * 40);
+        s = `${m}.${n - m * 40}`;
       } else {
-        s += "." + n.toString();
+        s += `.${n.toString()}`;
       }
       n = 0;
       bits = 0;
@@ -505,11 +521,11 @@ function readIntegerValue(buffer, block) {
   return value;
 }
 function readBooleanValue(buffer, block) {
-  assert(block.tag === 1 /* BOOLEAN */, "expecting a BOOLEAN tag. got " + TagType[block.tag]);
+  assert(block.tag === 1 /* BOOLEAN */, `expecting a BOOLEAN tag. got ${TagType[block.tag]}`);
   const pos = block.position;
   const nbBytes = block.length;
   assert(nbBytes < 4);
-  const value = buffer.readUInt8(pos) ? true : false;
+  const value = !!buffer.readUInt8(pos);
   return value;
 }
 function readVersionValue(buffer, block) {
@@ -561,7 +577,7 @@ function readValue(buffer, block) {
     case 24 /* GeneralizedTime */:
       return convertGeneralizedTime(getBlock(buffer, block).toString("ascii"));
     default:
-      throw new Error("Invalid tag 0x" + block.tag.toString(16));
+      throw new Error(`Invalid tag 0x${block.tag.toString(16)}`);
   }
 }
 function findBlockAtIndex(blocks, index) {
@@ -576,37 +592,235 @@ function readTime(buffer, block) {
 }
 
 // source/crypto_utils.ts
+import assert2 from "assert";
 import constants from "constants";
-import assert4 from "assert";
 import {
   createHash,
   createSign,
   createVerify,
-  publicEncrypt as publicEncrypt1,
-  privateDecrypt as privateDecrypt1
+  privateDecrypt as privateDecrypt1,
+  publicEncrypt as publicEncrypt1
 } from "crypto";
-import pkg_hexy from "hexy";
+import jsrsasign from "jsrsasign";
 
 // source/buffer_utils.ts
 var createFastUninitializedBuffer = Buffer.allocUnsafe ? Buffer.allocUnsafe : (size) => {
   return new Buffer(size);
 };
 
-// source/crypto_explore_certificate.ts
-import assert3 from "assert";
+// source/hexy.ts
+function hexy(buffer, { width, format } = {}) {
+  width = width || 80;
+  if (format === "twos") {
+    width = 26 * 3;
+  }
+  const regex = new RegExp(`.{1,${width}}`, "g");
+  const regexTwos = new RegExp(`.{1,${2}}`, "g");
+  let fullHex = buffer.toString("hex");
+  if (format === "twos") {
+    fullHex = fullHex.match(regexTwos)?.join(" ") || "";
+  }
+  return fullHex.match(regex)?.join("\n") || "";
+}
+
+// source/crypto_utils.ts
+var PEM_REGEX = /^(-----BEGIN (.*)-----\r?\n([/+=a-zA-Z0-9\r\n]*)\r?\n-----END \2-----\r?\n?)/gm;
+var PEM_TYPE_REGEX = /^(-----BEGIN (.*)-----)/m;
+function identifyPemType(rawKey) {
+  if (Buffer.isBuffer(rawKey)) {
+    rawKey = rawKey.toString("utf8");
+  }
+  const match = PEM_TYPE_REGEX.exec(rawKey);
+  return !match ? void 0 : match[2];
+}
+function removeTrailingLF(str) {
+  const tmp = str.replace(/(\r|\n)+$/m, "").replace(/\r\n/gm, "\n");
+  return tmp;
+}
+function toPem(raw_key, pem) {
+  assert2(raw_key, "expecting a key");
+  assert2(typeof pem === "string");
+  let pemType = identifyPemType(raw_key);
+  if (pemType) {
+    return Buffer.isBuffer(raw_key) ? removeTrailingLF(raw_key.toString("utf8")) : removeTrailingLF(raw_key);
+  } else {
+    pemType = pem;
+    assert2(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
+    let b = raw_key.toString("base64");
+    let str = `-----BEGIN ${pemType}-----
+`;
+    while (b.length) {
+      str += `${b.substring(0, 64)}
+`;
+      b = b.substring(64);
+    }
+    str += `-----END ${pemType}-----`;
+    return str;
+  }
+}
+function convertPEMtoDER(raw_key) {
+  let match;
+  let _pemType;
+  let base64str;
+  const parts = [];
+  PEM_REGEX.lastIndex = 0;
+  match = PEM_REGEX.exec(raw_key);
+  while (match !== null) {
+    _pemType = match[2];
+    base64str = match[3];
+    base64str = base64str.replace(/\r?\n/g, "");
+    parts.push(Buffer.from(base64str, "base64"));
+    match = PEM_REGEX.exec(raw_key);
+  }
+  return combine_der(parts);
+}
+function hexDump(buffer, width) {
+  if (!buffer) {
+    return "<>";
+  }
+  width = width || 32;
+  if (buffer.length > 1024) {
+    return `${hexy(buffer.subarray(0, 1024), { width, format: "twos" })}
+ .... ( ${buffer.length})`;
+  } else {
+    return hexy(buffer, { width, format: "twos" });
+  }
+}
+function makeMessageChunkSignature(chunk, options) {
+  const signer = createSign(options.algorithm);
+  signer.update(chunk);
+  const signature = signer.sign(options.privateKey.hidden);
+  assert2(!options.signatureLength || signature.length === options.signatureLength);
+  return signature;
+}
+function verifyMessageChunkSignature(blockToVerify, signature, options) {
+  const verify = createVerify(options.algorithm);
+  verify.update(blockToVerify);
+  return verify.verify(options.publicKey, signature);
+}
+function makeSHA1Thumbprint(buffer) {
+  return createHash("sha1").update(buffer).digest();
+}
+var RSA_PKCS1_OAEP_PADDING = constants.RSA_PKCS1_OAEP_PADDING;
+var RSA_PKCS1_PADDING = constants.RSA_PKCS1_PADDING;
+var PaddingAlgorithm = /* @__PURE__ */ ((PaddingAlgorithm2) => {
+  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_OAEP_PADDING"] = 4] = "RSA_PKCS1_OAEP_PADDING";
+  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_PADDING"] = 1] = "RSA_PKCS1_PADDING";
+  return PaddingAlgorithm2;
+})(PaddingAlgorithm || {});
+assert2(4 /* RSA_PKCS1_OAEP_PADDING */ === constants.RSA_PKCS1_OAEP_PADDING);
+assert2(1 /* RSA_PKCS1_PADDING */ === constants.RSA_PKCS1_PADDING);
+function publicEncrypt_native(buffer, publicKey, algorithm) {
+  if (algorithm === void 0) {
+    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
+  }
+  return publicEncrypt1(
+    {
+      key: publicKey,
+      padding: algorithm
+    },
+    buffer
+  );
+}
+function privateDecrypt_native(buffer, privateKey, algorithm) {
+  if (algorithm === void 0) {
+    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
+  }
+  try {
+    return privateDecrypt1(
+      {
+        key: privateKey.hidden,
+        padding: algorithm
+      },
+      buffer
+    );
+  } catch (_err) {
+    return Buffer.alloc(1);
+  }
+}
+var publicEncrypt = publicEncrypt_native;
+var privateDecrypt = privateDecrypt_native;
+function publicEncrypt_long(buffer, publicKey, blockSize, padding, paddingAlgorithm) {
+  if (paddingAlgorithm === void 0) {
+    paddingAlgorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
+  }
+  if (paddingAlgorithm === RSA_PKCS1_PADDING) {
+    padding = padding || 11;
+    if (padding !== 11) throw new Error("padding should be 11");
+  } else if (paddingAlgorithm === RSA_PKCS1_OAEP_PADDING) {
+    padding = padding || 42;
+    if (padding !== 42) throw new Error("padding should be 42");
+  } else {
+    throw new Error(`Invalid padding algorithm ${paddingAlgorithm}`);
+  }
+  const chunk_size = blockSize - padding;
+  const nbBlocks = Math.ceil(buffer.length / chunk_size);
+  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
+  for (let i = 0; i < nbBlocks; i++) {
+    const currentBlock = buffer.subarray(chunk_size * i, chunk_size * (i + 1));
+    const encrypted_chunk = publicEncrypt(currentBlock, publicKey, paddingAlgorithm);
+    if (encrypted_chunk.length !== blockSize) {
+      throw new Error(`publicEncrypt_long unexpected chunk length ${encrypted_chunk.length}  expecting ${blockSize}`);
+    }
+    encrypted_chunk.copy(outputBuffer, i * blockSize);
+  }
+  return outputBuffer;
+}
+function privateDecrypt_long(buffer, privateKey, blockSize, paddingAlgorithm) {
+  paddingAlgorithm = paddingAlgorithm || RSA_PKCS1_OAEP_PADDING;
+  if (paddingAlgorithm !== RSA_PKCS1_PADDING && paddingAlgorithm !== RSA_PKCS1_OAEP_PADDING) {
+    throw new Error(`Invalid padding algorithm ${paddingAlgorithm}`);
+  }
+  const nbBlocks = Math.ceil(buffer.length / blockSize);
+  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
+  let total_length = 0;
+  for (let i = 0; i < nbBlocks; i++) {
+    const currentBlock = buffer.subarray(blockSize * i, Math.min(blockSize * (i + 1), buffer.length));
+    const decrypted_buf = privateDecrypt(currentBlock, privateKey, paddingAlgorithm);
+    decrypted_buf.copy(outputBuffer, total_length);
+    total_length += decrypted_buf.length;
+  }
+  return outputBuffer.subarray(0, total_length);
+}
+function coerceCertificatePem(certificate) {
+  if (Buffer.isBuffer(certificate)) {
+    certificate = toPem(certificate, "CERTIFICATE");
+  }
+  assert2(typeof certificate === "string");
+  return certificate;
+}
+function extractPublicKeyFromCertificateSync(certificate) {
+  certificate = coerceCertificatePem(certificate);
+  const key = jsrsasign.KEYUTIL.getKey(certificate);
+  const publicKeyAsPem = jsrsasign.KEYUTIL.getPEM(key);
+  assert2(typeof publicKeyAsPem === "string");
+  return publicKeyAsPem;
+}
+function extractPublicKeyFromCertificate(certificate, callback) {
+  let err1 = null;
+  let keyPem;
+  try {
+    keyPem = extractPublicKeyFromCertificateSync(certificate);
+  } catch (err) {
+    err1 = err;
+  }
+  setImmediate(() => {
+    callback(err1, keyPem);
+  });
+}
 
 // source/directory_name.ts
-import assert2 from "assert";
+import assert3 from "assert";
 function readDirectoryName(buffer, block) {
   const set_blocks = readStruct(buffer, block);
   const names = {};
   for (const set_block of set_blocks) {
-    assert2(set_block.tag === 49);
+    assert3(set_block.tag === 49);
     const blocks = readStruct(buffer, set_block);
-    assert2(blocks.length === 1);
-    assert2(blocks[0].tag === 48);
+    assert3(blocks.length === 1);
+    assert3(blocks[0].tag === 48);
     const sequenceBlock = readStruct(buffer, blocks[0]);
-    assert2(sequenceBlock.length === 2);
+    assert3(sequenceBlock.length === 2);
     const type = readObjectIdentifier(buffer, sequenceBlock[0]);
     names[type.name] = readValue(buffer, sequenceBlock[1]);
   }
@@ -686,7 +900,7 @@ function _readAuthorityKeyIdentifier(buffer) {
     // can be null for self-signed certf
   };
 }
-function readBasicConstraint2_5_29_19(buffer, block) {
+function readBasicConstraint2_5_29_19(buffer, _block) {
   const block_info = readTag(buffer, 0);
   const inner_blocks = readStruct(buffer, block_info).slice(0, 2);
   let cA = false;
@@ -731,14 +945,14 @@ function _readGeneralNames(buffer, block) {
   }
   const n = {};
   for (const block2 of blocks) {
-    assert3((block2.tag & 128) === 128);
+    assert4((block2.tag & 128) === 128);
     const t2 = block2.tag & 127;
     const type = _data[t2];
     if (!type) {
-      console.log("_readGeneralNames: INVALID TYPE => " + t2 + " 0x" + t2.toString(16));
+      console.log(`_readGeneralNames: INVALID TYPE => ${t2} 0x${t2.toString(16)}`);
       continue;
     }
-    if (t2 == 32) {
+    if (t2 === 32) {
       n[type.name] = n[type.name] || [];
       const blocks2 = readStruct(buffer, block2);
       const name = readObjectIdentifier(buffer, blocks2[0]).name;
@@ -761,7 +975,7 @@ function _readSubjectAltNames(buffer) {
   const block_info = readTag(buffer, 0);
   return _readGeneralNames(buffer, block_info);
 }
-function readKeyUsage(oid, buffer) {
+function readKeyUsage(_oid, buffer) {
   const block_info = readTag(buffer, 0);
   let b2 = 0;
   let b3 = 0;
@@ -791,7 +1005,7 @@ function readKeyUsage(oid, buffer) {
   };
 }
 function readExtKeyUsage(oid, buffer) {
-  assert3(oid === "2.5.29.37");
+  assert4(oid === "2.5.29.37");
   const block_info = readTag(buffer, 0);
   const inner_blocks = readStruct(buffer, block_info);
   const extKeyUsage = {
@@ -821,7 +1035,7 @@ function _readSubjectPublicKey(buffer) {
 function readExtension(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
   if (inner_blocks.length === 3) {
-    assert3(inner_blocks[1].tag === 1 /* BOOLEAN */);
+    assert4(inner_blocks[1].tag === 1 /* BOOLEAN */);
     inner_blocks[1] = inner_blocks[2];
   }
   const identifier = readObjectIdentifier(buffer, inner_blocks[0]);
@@ -841,7 +1055,7 @@ function readExtension(buffer, block) {
       value = readBasicConstraint2_5_29_19(buf, inner_blocks[1]);
       break;
     case "certExtension":
-      value = "basicConstraints ( not implemented yet) " + buf.toString("hex");
+      value = `basicConstraints ( not implemented yet) ${buf.toString("hex")}`;
       break;
     case "extKeyUsage":
       value = readExtKeyUsage(identifier.oid, buf);
@@ -850,7 +1064,7 @@ function readExtension(buffer, block) {
       value = readKeyUsage(identifier.oid, buf);
       break;
     default:
-      value = "Unknown " + identifier.name + buf.toString("hex");
+      value = `Unknown ${identifier.name}${buf.toString("hex")}`;
   }
   return {
     identifier,
@@ -858,7 +1072,7 @@ function readExtension(buffer, block) {
   };
 }
 function _readExtensions(buffer, block) {
-  assert3(block.tag === 163);
+  assert4(block.tag === 163);
   let inner_blocks = readStruct(buffer, block);
   inner_blocks = readStruct(buffer, inner_blocks[0]);
   const extensions = inner_blocks.map((block2) => readExtension(buffer, block2));
@@ -897,10 +1111,17 @@ function _readSubjectECCPublicKeyInfo(buffer, block) {
 }
 function readTbsCertificate(buffer, block) {
   const blocks = readStruct(buffer, block);
-  let version, serialNumber, signature, issuer, validity, subject, subjectFingerPrint, extensions;
+  let _version;
+  let serialNumber;
+  let signature;
+  let issuer;
+  let validity;
+  let subject;
+  let subjectFingerPrint;
+  let extensions;
   let subjectPublicKeyInfo;
   if (blocks.length === 6) {
-    version = 1;
+    _version = 1;
     serialNumber = formatBuffer2DigitHexWithColum(readLongIntegerValue(buffer, blocks[0]));
     signature = readAlgorithmIdentifier(buffer, blocks[1]);
     issuer = _readName(buffer, blocks[2]);
@@ -914,7 +1135,7 @@ function readTbsCertificate(buffer, block) {
     if (!version_block) {
       throw new Error("cannot find version block");
     }
-    version = readVersionValue(buffer, version_block) + 1;
+    _version = readVersionValue(buffer, version_block) + 1;
     serialNumber = formatBuffer2DigitHexWithColum(readLongIntegerValue(buffer, blocks[1]));
     signature = readAlgorithmIdentifier(buffer, blocks[2]);
     issuer = _readName(buffer, blocks[3]);
@@ -928,371 +1149,70 @@ function readTbsCertificate(buffer, block) {
         subjectPublicKeyInfo = _readSubjectPublicKeyInfo(buffer, blocks[6]);
         break;
       }
-      case "ecPublicKey":
       default: {
+        assert4(what_type === "ecPublicKey");
         subjectPublicKeyInfo = _readSubjectECCPublicKeyInfo(buffer, blocks[6]);
         break;
       }
     }
     const extensionBlock = findBlockAtIndex(blocks, 3);
     if (!extensionBlock) {
-      doDebug && console.log("X509 certificate is invalid : cannot find extension block version =" + version_block);
+      doDebug && console.log(`X509 certificate is invalid : cannot find extension block version = ${version_block}`);
       extensions = null;
     } else {
       extensions = _readExtensions(buffer, extensionBlock);
     }
   }
-  return {
-    version,
-    serialNumber,
-    signature,
-    issuer,
-    validity,
-    subject,
-    subjectFingerPrint,
-    subjectPublicKeyInfo,
-    extensions
-  };
-}
-function exploreCertificate(certificate) {
-  assert3(Buffer.isBuffer(certificate));
-  if (!certificate._exploreCertificate_cache) {
-    const block_info = readTag(certificate, 0);
-    const blocks = readStruct(certificate, block_info);
-    certificate._exploreCertificate_cache = {
-      tbsCertificate: readTbsCertificate(certificate, blocks[0]),
-      signatureAlgorithm: readAlgorithmIdentifier(certificate, blocks[1]),
-      signatureValue: readSignatureValue(certificate, blocks[2])
-    };
-  }
-  return certificate._exploreCertificate_cache;
-}
-function split_der(certificateChain) {
-  const certificate_chain = [];
-  do {
-    const block_info = readTag(certificateChain, 0);
-    const length = block_info.position + block_info.length;
-    const der_certificate = certificateChain.subarray(0, length);
-    certificate_chain.push(der_certificate);
-    certificateChain = certificateChain.subarray(length);
-  } while (certificateChain.length > 0);
-  return certificate_chain;
-}
-function combine_der(certificates) {
-  for (const cert of certificates) {
-    const b = split_der(cert);
-    let sum = 0;
-    b.forEach((block) => {
-      const block_info = readTag(block, 0);
-      assert3(block_info.position + block_info.length === block.length);
-      sum += block.length;
-    });
-    assert3(sum === cert.length);
-  }
-  return Buffer.concat(certificates);
-}
-
-// source/crypto_utils.ts
-import jsrsasign from "jsrsasign";
-var { hexy } = pkg_hexy;
-var PEM_REGEX = /^(-----BEGIN (.*)-----\r?\n([/+=a-zA-Z0-9\r\n]*)\r?\n-----END \2-----\r?\n?)/gm;
-var PEM_TYPE_REGEX = /^(-----BEGIN (.*)-----)/m;
-function identifyPemType(rawKey) {
-  if (Buffer.isBuffer(rawKey)) {
-    rawKey = rawKey.toString("utf8");
-  }
-  const match = PEM_TYPE_REGEX.exec(rawKey);
-  return !match ? void 0 : match[2];
-}
-function removeTrailingLF(str) {
-  const tmp = str.replace(/(\r|\n)+$/m, "").replace(/\r\n/gm, "\n");
-  return tmp;
-}
-function toPem(raw_key, pem) {
-  assert4(raw_key, "expecting a key");
-  assert4(typeof pem === "string");
-  let pemType = identifyPemType(raw_key);
-  if (pemType) {
-    return Buffer.isBuffer(raw_key) ? removeTrailingLF(raw_key.toString("utf8")) : removeTrailingLF(raw_key);
-  } else {
-    pemType = pem;
-    assert4(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
-    let b = raw_key.toString("base64");
-    let str = "-----BEGIN " + pemType + "-----\n";
-    while (b.length) {
-      str += b.substring(0, 64) + "\n";
-      b = b.substring(64);
-    }
-    str += "-----END " + pemType + "-----";
-    return str;
-  }
-}
-function convertPEMtoDER(raw_key) {
-  let match;
-  let pemType;
-  let base64str;
-  const parts = [];
-  PEM_REGEX.lastIndex = 0;
-  while ((match = PEM_REGEX.exec(raw_key)) !== null) {
-    pemType = match[2];
-    base64str = match[3];
-    base64str = base64str.replace(/\r?\n/g, "");
-    parts.push(Buffer.from(base64str, "base64"));
-  }
-  return combine_der(parts);
-}
-function hexDump(buffer, width) {
-  if (!buffer) {
-    return "<>";
-  }
-  width = width || 32;
-  if (buffer.length > 1024) {
-    return hexy(buffer.subarray(0, 1024), { width, format: "twos" }) + "\n .... ( " + buffer.length + ")";
-  } else {
-    return hexy(buffer, { width, format: "twos" });
-  }
-}
-function makeMessageChunkSignature(chunk, options) {
-  const signer = createSign(options.algorithm);
-  signer.update(chunk);
-  const signature = signer.sign(options.privateKey.hidden);
-  assert4(!options.signatureLength || signature.length === options.signatureLength);
-  return signature;
-}
-function verifyMessageChunkSignature(blockToVerify, signature, options) {
-  const verify = createVerify(options.algorithm);
-  verify.update(blockToVerify);
-  return verify.verify(options.publicKey, signature);
-}
-function makeSHA1Thumbprint(buffer) {
-  return createHash("sha1").update(buffer).digest();
-}
-var RSA_PKCS1_OAEP_PADDING = constants.RSA_PKCS1_OAEP_PADDING;
-var RSA_PKCS1_PADDING = constants.RSA_PKCS1_PADDING;
-var PaddingAlgorithm = /* @__PURE__ */ ((PaddingAlgorithm2) => {
-  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_OAEP_PADDING"] = 4] = "RSA_PKCS1_OAEP_PADDING";
-  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_PADDING"] = 1] = "RSA_PKCS1_PADDING";
-  return PaddingAlgorithm2;
-})(PaddingAlgorithm || {});
-assert4(4 /* RSA_PKCS1_OAEP_PADDING */ === constants.RSA_PKCS1_OAEP_PADDING);
-assert4(1 /* RSA_PKCS1_PADDING */ === constants.RSA_PKCS1_PADDING);
-function publicEncrypt_native(buffer, publicKey, algorithm) {
-  if (algorithm === void 0) {
-    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
-  }
-  return publicEncrypt1(
-    {
-      key: publicKey,
-      padding: algorithm
-    },
-    buffer
-  );
-}
-function privateDecrypt_native(buffer, privateKey, algorithm) {
-  if (algorithm === void 0) {
-    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
-  }
-  try {
-    return privateDecrypt1(
-      {
-        key: privateKey.hidden,
-        padding: algorithm
-      },
-      buffer
-    );
-  } catch (err) {
-    return Buffer.alloc(1);
-  }
-}
-var publicEncrypt = publicEncrypt_native;
-var privateDecrypt = privateDecrypt_native;
-function publicEncrypt_long(buffer, publicKey, blockSize, padding, paddingAlgorithm) {
-  if (paddingAlgorithm === void 0) {
-    paddingAlgorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
-  }
-  if (paddingAlgorithm === RSA_PKCS1_PADDING) {
-    padding = padding || 11;
-    if (padding !== 11) throw new Error("padding should be 11");
-  } else if (paddingAlgorithm === RSA_PKCS1_OAEP_PADDING) {
-    padding = padding || 42;
-    if (padding !== 42) throw new Error("padding should be 42");
-  } else {
-    throw new Error("Invalid padding algorithm " + paddingAlgorithm);
-  }
-  const chunk_size = blockSize - padding;
-  const nbBlocks = Math.ceil(buffer.length / chunk_size);
-  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
-  for (let i = 0; i < nbBlocks; i++) {
-    const currentBlock = buffer.subarray(chunk_size * i, chunk_size * (i + 1));
-    const encrypted_chunk = publicEncrypt(currentBlock, publicKey, paddingAlgorithm);
-    if (encrypted_chunk.length !== blockSize) {
-      throw new Error(`publicEncrypt_long unexpected chunk length ${encrypted_chunk.length}  expecting ${blockSize}`);
-    }
-    encrypted_chunk.copy(outputBuffer, i * blockSize);
-  }
-  return outputBuffer;
-}
-function privateDecrypt_long(buffer, privateKey, blockSize, paddingAlgorithm) {
-  paddingAlgorithm = paddingAlgorithm || RSA_PKCS1_OAEP_PADDING;
-  if (paddingAlgorithm !== RSA_PKCS1_PADDING && paddingAlgorithm !== RSA_PKCS1_OAEP_PADDING) {
-    throw new Error("Invalid padding algorithm " + paddingAlgorithm);
-  }
-  const nbBlocks = Math.ceil(buffer.length / blockSize);
-  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
-  let total_length = 0;
-  for (let i = 0; i < nbBlocks; i++) {
-    const currentBlock = buffer.subarray(blockSize * i, Math.min(blockSize * (i + 1), buffer.length));
-    const decrypted_buf = privateDecrypt(currentBlock, privateKey, paddingAlgorithm);
-    decrypted_buf.copy(outputBuffer, total_length);
-    total_length += decrypted_buf.length;
-  }
-  return outputBuffer.subarray(0, total_length);
-}
-function coerceCertificatePem(certificate) {
-  if (Buffer.isBuffer(certificate)) {
-    certificate = toPem(certificate, "CERTIFICATE");
-  }
-  assert4(typeof certificate === "string");
-  return certificate;
-}
-function extractPublicKeyFromCertificateSync(certificate) {
-  certificate = coerceCertificatePem(certificate);
-  const key = jsrsasign.KEYUTIL.getKey(certificate);
-  const publicKeyAsPem = jsrsasign.KEYUTIL.getPEM(key);
-  assert4(typeof publicKeyAsPem === "string");
-  return publicKeyAsPem;
-}
-function extractPublicKeyFromCertificate(certificate, callback) {
-  let err1 = null;
-  let keyPem;
-  try {
-    keyPem = extractPublicKeyFromCertificateSync(certificate);
-  } catch (err) {
-    err1 = err;
-  }
-  setImmediate(() => {
-    callback(err1, keyPem);
-  });
-}
-
-// source/explore_private_key.ts
-function f(buffer, b) {
-  return buffer.subarray(b.position + 1, b.position + b.length);
-}
-var doDebug2 = !!process.env.DEBUG;
-function explorePrivateKey(privateKey2) {
-  const privateKey1 = privateKey2.hidden;
-  const privateKey = typeof privateKey1 === "string" ? convertPEMtoDER(privateKey1) : privateKey1.export({ format: "der", type: "pkcs1" });
-  const block_info = readTag(privateKey, 0);
-  const blocks = readStruct(privateKey, block_info);
-  if (blocks.length === 9) {
-    const version2 = f(privateKey, blocks[0]);
-    const modulus2 = f(privateKey, blocks[1]);
-    const publicExponent2 = f(privateKey, blocks[2]);
-    const privateExponent2 = f(privateKey, blocks[3]);
-    const prime12 = f(privateKey, blocks[4]);
-    const prime22 = f(privateKey, blocks[5]);
-    const exponent12 = f(privateKey, blocks[6]);
-    const exponent22 = f(privateKey, blocks[7]);
-    return {
-      version: version2,
-      modulus: modulus2,
-      publicExponent: publicExponent2,
-      privateExponent: privateExponent2,
-      prime1: prime12,
-      prime2: prime22,
-      exponent1: exponent12,
-      exponent2: exponent22
-    };
-  }
-  if (doDebug2) {
-    console.log("-------------------- private key:");
-    console.log(block_info);
-    console.log(
-      blocks.map((b2) => ({
-        tag: TagType[b2.tag] + " 0x" + b2.tag.toString(16),
-        l: b2.length,
-        p: b2.position,
-        buff: privateKey.subarray(b2.position, b2.position + b2.length).toString("hex")
-      }))
-    );
-  }
-  const b = blocks[2];
-  const bb = privateKey.subarray(b.position, b.position + b.length);
-  const block_info1 = readTag(bb, 0);
-  const blocks1 = readStruct(bb, block_info1);
-  if (doDebug2) {
-    console.log(
-      blocks1.map((b2) => ({
-        tag: TagType[b2.tag] + " 0x" + b2.tag.toString(16),
-        l: b2.length,
-        p: b2.position,
-        buff: bb.subarray(b2.position, b2.position + b2.length).toString("hex")
-      }))
-    );
-  }
-  const version = f(bb, blocks1[0]);
-  const modulus = f(bb, blocks1[1]);
-  const publicExponent = f(bb, blocks1[2]);
-  const privateExponent = f(bb, blocks1[3]);
-  const prime1 = f(bb, blocks1[4]);
-  const prime2 = f(bb, blocks1[5]);
-  const exponent1 = f(bb, blocks1[6]);
-  const exponent2 = f(bb, blocks1[7]);
-  return {
-    version,
-    modulus,
-    publicExponent,
-    privateExponent,
-    prime1,
-    prime2,
-    exponent1,
-    exponent2
+  return {
+    version: _version,
+    serialNumber,
+    signature,
+    issuer,
+    validity,
+    subject,
+    subjectFingerPrint,
+    subjectPublicKeyInfo,
+    extensions
   };
 }
-
-// source/public_private_match.ts
-function publicKeyAndPrivateKeyMatches(certificate, privateKey) {
-  const i = exploreCertificate(certificate);
-  const j = explorePrivateKey(privateKey);
-  const modulus1 = i.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey.modulus;
-  const modulus2 = j.modulus;
-  if (modulus1.length != modulus2.length) {
-    return false;
+function exploreCertificate(certificate) {
+  assert4(Buffer.isBuffer(certificate));
+  const certificate_priv = certificate;
+  if (!certificate_priv._exploreCertificate_cache) {
+    const block_info = readTag(certificate, 0);
+    const blocks = readStruct(certificate, block_info);
+    certificate_priv._exploreCertificate_cache = {
+      tbsCertificate: readTbsCertificate(certificate, blocks[0]),
+      signatureAlgorithm: readAlgorithmIdentifier(certificate, blocks[1]),
+      signatureValue: readSignatureValue(certificate, blocks[2])
+    };
   }
-  return modulus1.toString("hex") === modulus2.toString("hex");
-}
-function certificateMatchesPrivateKeyPEM(certificate, privateKey, blockSize) {
-  const initialBuffer = Buffer.from("Lorem Ipsum");
-  const encryptedBuffer = publicEncrypt_long(initialBuffer, certificate, blockSize);
-  const decryptedBuffer = privateDecrypt_long(encryptedBuffer, privateKey, blockSize);
-  const finalString = decryptedBuffer.toString("utf-8");
-  return initialBuffer.toString("utf-8") === finalString;
+  return certificate_priv._exploreCertificate_cache;
 }
-function certificateMatchesPrivateKey(certificate, privateKey) {
-  const e = explorePrivateKey(privateKey);
-  const blockSize = e.modulus.length;
-  const certificatePEM = toPem(certificate, "CERTIFICATE");
-  return certificateMatchesPrivateKeyPEM(certificatePEM, privateKey, blockSize);
+function split_der(certificateChain) {
+  const certificate_chain = [];
+  do {
+    const block_info = readTag(certificateChain, 0);
+    const length = block_info.position + block_info.length;
+    const der_certificate = certificateChain.subarray(0, length);
+    certificate_chain.push(der_certificate);
+    certificateChain = certificateChain.subarray(length);
+  } while (certificateChain.length > 0);
+  return certificate_chain;
 }
-
-// source/common.ts
-import __crypto from "crypto";
-var KeyObjectOrig = __crypto.KeyObject;
-var { createPrivateKey: createPrivateKeyFromNodeJSCrypto } = __crypto;
-function isKeyObject(mayBeKeyObject) {
-  if (KeyObjectOrig) {
-    return mayBeKeyObject instanceof KeyObjectOrig;
+function combine_der(certificates) {
+  for (const cert of certificates) {
+    const b = split_der(cert);
+    let sum = 0;
+    b.forEach((block) => {
+      const block_info = readTag(block, 0);
+      assert4(block_info.position + block_info.length === block.length);
+      sum += block.length;
+    });
+    assert4(sum === cert.length);
   }
-  return typeof mayBeKeyObject === "object" && typeof mayBeKeyObject.type === "string";
+  return Buffer.concat(certificates);
 }
-var CertificatePurpose = /* @__PURE__ */ ((CertificatePurpose2) => {
-  CertificatePurpose2[CertificatePurpose2["NotSpecified"] = 0] = "NotSpecified";
-  CertificatePurpose2[CertificatePurpose2["ForCertificateAuthority"] = 1] = "ForCertificateAuthority";
-  CertificatePurpose2[CertificatePurpose2["ForApplication"] = 2] = "ForApplication";
-  CertificatePurpose2[CertificatePurpose2["ForUserAuthentication"] = 3] = "ForUserAuthentication";
-  return CertificatePurpose2;
-})(CertificatePurpose || {});
 
 // source/crypto_utils2.ts
 import assert5 from "assert";
@@ -1374,7 +1294,7 @@ function exploreCertificateInfo(certificate) {
     subject: certInfo.tbsCertificate.subject
   };
   if (!(data.publicKeyLength === 512 || data.publicKeyLength === 384 || data.publicKeyLength === 256 || data.publicKeyLength === 128)) {
-    throw new Error("Invalid public key length (expecting 128,256,384 or 512)" + data.publicKeyLength);
+    throw new Error(`Invalid public key length (expecting 128,256,384 or 512): ${data.publicKeyLength}`);
   }
   return data;
 }
@@ -1442,14 +1362,14 @@ function verifyChunkSignature(chunk, options) {
   return verifyMessageChunkSignature(block_to_verify, signature, options);
 }
 function computePaddingFooter(buffer, derivedKeys) {
-  assert7(Object.prototype.hasOwnProperty.call(derivedKeys, "encryptingBlockSize"));
+  assert7(Object.hasOwn(derivedKeys, "encryptingBlockSize"));
   const paddingSize = derivedKeys.encryptingBlockSize - (buffer.length + 1) % derivedKeys.encryptingBlockSize;
   const padding = createFastUninitializedBuffer(paddingSize + 1);
   padding.fill(paddingSize);
   return padding;
 }
 function derivedKeys_algorithm(derivedKeys) {
-  assert7(Object.prototype.hasOwnProperty.call(derivedKeys, "algorithm"));
+  assert7(Object.hasOwn(derivedKeys, "algorithm"));
   const algorithm = derivedKeys.algorithm || "aes-128-cbc";
   assert7(algorithm === "aes-128-cbc" || algorithm === "aes-256-cbc");
   return algorithm;
@@ -1527,7 +1447,7 @@ function _readTbsCertList(buffer, blockInfo) {
   const blocks = readStruct(buffer, blockInfo);
   const hasOptionalVersion = blocks[0].tag === 2 /* INTEGER */;
   if (hasOptionalVersion) {
-    const version = readIntegerValue(buffer, blocks[0]);
+    const _version = readIntegerValue(buffer, blocks[0]);
     const signature = readAlgorithmIdentifier(buffer, blocks[1]);
     const issuer = readNameForCrl(buffer, blocks[2]);
     const issuerFingerprint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(getBlock(buffer, blocks[2])));
@@ -1546,7 +1466,7 @@ function _readTbsCertList(buffer, blockInfo) {
         });
       }
     }
-    const ext0 = findBlockAtIndex(blocks, 0);
+    const _ext0 = findBlockAtIndex(blocks, 0);
     return { issuer, issuerFingerprint, thisUpdate, nextUpdate, signature, revokedCertificates };
   } else {
     const signature = readAlgorithmIdentifier(buffer, blocks[0]);
@@ -1586,10 +1506,21 @@ function _readExtensionRequest(buffer) {
   const extensions = inner_blocks.map((block1) => readExtension(buffer, block1));
   const result = {};
   for (const e of extensions) {
-    result[e.identifier.name] = e.value;
+    switch (e.identifier.name) {
+      case "basicConstraints":
+        result.basicConstraints = e.value;
+        break;
+      case "keyUsage":
+        result.keyUsage = e.value;
+        break;
+      case "subjectAltName":
+        result.subjectAltName = e.value;
+        break;
+      default:
+        break;
+    }
   }
-  const { basicConstraints, keyUsage, subjectAltName } = result;
-  return { basicConstraints, keyUsage, subjectAltName };
+  return result;
 }
 function readCertificationRequestInfo(buffer, block) {
   const blocks = readStruct(buffer, block);
@@ -1617,16 +1548,117 @@ function exploreCertificateSigningRequest(crl) {
   return csrInfo;
 }
 
+// source/explore_private_key.ts
+function f(buffer, b) {
+  return buffer.subarray(b.position + 1, b.position + b.length);
+}
+var doDebug2 = !!process.env.DEBUG;
+function explorePrivateKey(privateKey2) {
+  const privateKey1 = privateKey2.hidden;
+  const privateKey = typeof privateKey1 === "string" ? convertPEMtoDER(privateKey1) : privateKey1.export({ format: "der", type: "pkcs1" });
+  const block_info = readTag(privateKey, 0);
+  const blocks = readStruct(privateKey, block_info);
+  if (blocks.length === 9) {
+    const version2 = f(privateKey, blocks[0]);
+    const modulus2 = f(privateKey, blocks[1]);
+    const publicExponent2 = f(privateKey, blocks[2]);
+    const privateExponent2 = f(privateKey, blocks[3]);
+    const prime12 = f(privateKey, blocks[4]);
+    const prime22 = f(privateKey, blocks[5]);
+    const exponent12 = f(privateKey, blocks[6]);
+    const exponent22 = f(privateKey, blocks[7]);
+    return {
+      version: version2,
+      modulus: modulus2,
+      publicExponent: publicExponent2,
+      privateExponent: privateExponent2,
+      prime1: prime12,
+      prime2: prime22,
+      exponent1: exponent12,
+      exponent2: exponent22
+    };
+  }
+  if (doDebug2) {
+    console.log("-------------------- private key:");
+    console.log(block_info);
+    console.log(
+      blocks.map((b2) => ({
+        tag: `${TagType[b2.tag]} 0x${b2.tag.toString(16)}`,
+        l: b2.length,
+        p: b2.position,
+        buff: privateKey.subarray(b2.position, b2.position + b2.length).toString("hex")
+      }))
+    );
+  }
+  const b = blocks[2];
+  const bb = privateKey.subarray(b.position, b.position + b.length);
+  const block_info1 = readTag(bb, 0);
+  const blocks1 = readStruct(bb, block_info1);
+  if (doDebug2) {
+    console.log(
+      blocks1.map((b2) => ({
+        tag: `${TagType[b2.tag]} 0x${b2.tag.toString(16)}`,
+        l: b2.length,
+        p: b2.position,
+        buff: bb.subarray(b2.position, b2.position + b2.length).toString("hex")
+      }))
+    );
+  }
+  const version = f(bb, blocks1[0]);
+  const modulus = f(bb, blocks1[1]);
+  const publicExponent = f(bb, blocks1[2]);
+  const privateExponent = f(bb, blocks1[3]);
+  const prime1 = f(bb, blocks1[4]);
+  const prime2 = f(bb, blocks1[5]);
+  const exponent1 = f(bb, blocks1[6]);
+  const exponent2 = f(bb, blocks1[7]);
+  return {
+    version,
+    modulus,
+    publicExponent,
+    privateExponent,
+    prime1,
+    prime2,
+    exponent1,
+    exponent2
+  };
+}
+
 // source/make_private_key_from_pem.ts
 function makePrivateKeyFromPem(privateKeyInPem) {
   return { hidden: privateKeyInPem };
 }
 
 // source/make_private_key_thumbprint.ts
-function makePrivateKeyThumbPrint(privateKey) {
+function makePrivateKeyThumbPrint(_privateKey) {
   return Buffer.alloc(0);
 }
 
+// source/public_private_match.ts
+function publicKeyAndPrivateKeyMatches(certificate, privateKey) {
+  const i = exploreCertificate(certificate);
+  const j = explorePrivateKey(privateKey);
+  const modulus1 = i.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey.modulus;
+  const modulus2 = j.modulus;
+  if (modulus1.length !== modulus2.length) {
+    return false;
+  }
+  return modulus1.toString("hex") === modulus2.toString("hex");
+}
+function certificateMatchesPrivateKeyPEM(certificate, privateKey, blockSize) {
+  const initialBuffer = Buffer.from("Lorem Ipsum");
+  const encryptedBuffer = publicEncrypt_long(initialBuffer, certificate, blockSize);
+  const decryptedBuffer = privateDecrypt_long(encryptedBuffer, privateKey, blockSize);
+  const finalString = decryptedBuffer.toString("utf-8");
+  return initialBuffer.toString("utf-8") === finalString;
+}
+function certificateMatchesPrivateKey(certificate, privateKey) {
+  const e = explorePrivateKey(privateKey);
+  const blockSize = e.modulus.length;
+  const certificatePEM = toPem(certificate, "CERTIFICATE");
+  return certificateMatchesPrivateKeyPEM(certificatePEM, privateKey, blockSize);
+}
+
 // source/subject.ts
 var _keys = {
   C: "country",
@@ -1669,11 +1701,11 @@ var Subject = class _Subject {
       }
       const s = element.split("=");
       if (s.length !== 2) {
-        throw new Error("invalid format for " + element);
+        throw new Error(`invalid format for ${element}`);
       }
       const longName = _keys[s[0]];
       if (!longName) {
-        throw new Error("Invalid field found in subject name " + s[0]);
+        throw new Error(`Invalid field found in subject name ${s[0]}`);
       }
       const value = s[1];
       options[longName] = unquote(Buffer.from(value, "ascii").toString("utf8"));
@@ -1683,25 +1715,25 @@ var Subject = class _Subject {
   toStringInternal(sep) {
     const tmp = [];
     if (this.country) {
-      tmp.push("C=" + enquoteIfNecessary(this.country));
+      tmp.push(`C=${enquoteIfNecessary(this.country)}`);
     }
     if (this.state) {
-      tmp.push("ST=" + enquoteIfNecessary(this.state));
+      tmp.push(`ST=${enquoteIfNecessary(this.state)}`);
     }
     if (this.locality) {
-      tmp.push("L=" + enquoteIfNecessary(this.locality));
+      tmp.push(`L=${enquoteIfNecessary(this.locality)}`);
     }
     if (this.organization) {
-      tmp.push("O=" + enquoteIfNecessary(this.organization));
+      tmp.push(`O=${enquoteIfNecessary(this.organization)}`);
     }
     if (this.organizationalUnit) {
-      tmp.push("OU=" + enquoteIfNecessary(this.organizationalUnit));
+      tmp.push(`OU=${enquoteIfNecessary(this.organizationalUnit)}`);
     }
     if (this.commonName) {
-      tmp.push("CN=" + enquoteIfNecessary(this.commonName));
+      tmp.push(`CN=${enquoteIfNecessary(this.commonName)}`);
     }
     if (this.domainComponent) {
-      tmp.push("DC=" + enquoteIfNecessary(this.domainComponent));
+      tmp.push(`DC=${enquoteIfNecessary(this.domainComponent)}`);
     }
     return tmp.join(sep);
   }
@@ -1710,7 +1742,7 @@ var Subject = class _Subject {
   }
   toString() {
     const t2 = this.toStringForOPCUA();
-    return t2 ? "/" + t2 : t2;
+    return t2 ? `/${t2}` : t2;
   }
 };
 
@@ -1740,8 +1772,8 @@ async function verifyCertificateChain(certificateChain) {
     const cert = certificateChain[index - 1];
     const certParent = certificateChain[index];
     const certParentInfo = exploreCertificate(certParent);
-    const keyUsage = certParentInfo.tbsCertificate.extensions.keyUsage;
-    if (!keyUsage.keyCertSign) {
+    const keyUsage = certParentInfo.tbsCertificate.extensions?.keyUsage;
+    if (!keyUsage || !keyUsage.keyCertSign) {
       return {
         status: "BadCertificateIssuerUseNotAllowed",
         reason: "One of the certificate in the chain has not keyUsage set for Certificate Signing"
@@ -1781,9 +1813,9 @@ async function verifyCertificateChain(certificateChain) {
 }
 
 // source/x509/_crypto.ts
-import * as x509 from "@peculiar/x509";
-import { Crypto as PeculiarWebCrypto } from "@peculiar/webcrypto";
 import nativeCrypto from "crypto";
+import { Crypto as PeculiarWebCrypto } from "@peculiar/webcrypto";
+import * as x509 from "@peculiar/x509";
 import * as x5092 from "@peculiar/x509";
 var doDebug3 = false;
 var _crypto;
@@ -1803,7 +1835,7 @@ if (typeof window === "undefined") {
   x509.cryptoProvider.set(crypto);
 }
 function getCrypto() {
-  return _crypto || crypto || __require("crypto");
+  return _crypto || crypto || nativeCrypto;
 }
 
 // source/x509/create_key_pair.ts
@@ -1829,7 +1861,7 @@ async function privateKeyToPEM(privateKey) {
 }
 async function derToPrivateKey(privDer) {
   const crypto3 = getCrypto();
-  return await crypto3.subtle.importKey(
+  const importedKey = await crypto3.subtle.importKey(
     "pkcs8",
     privDer,
     {
@@ -1848,6 +1880,7 @@ async function derToPrivateKey(privDer) {
       //    "deriveBits"
     ]
   );
+  return importedKey;
 }
 async function pemToPrivateKey(pem) {
   const privDer = x5092.PemConverter.decode(pem);
@@ -1865,24 +1898,46 @@ function coercePEMorDerToPrivateKey(privateKeyInDerOrPem) {
   throw new Error("not implemented");
 }
 async function _coercePrivateKey(privateKey) {
-  const KeyObject4 = crypto2.KeyObject;
+  const KeyObject = crypto2.KeyObject;
   if (Buffer.isBuffer(privateKey)) {
     const privateKey1 = await derToPrivateKey(privateKey);
-    return KeyObject4.from(privateKey1);
+    return KeyObject.from(privateKey1);
   } else if (typeof privateKey === "string") {
     try {
       const privateKey1 = await pemToPrivateKey(privateKey);
-      return KeyObject4.from(privateKey1);
+      return KeyObject.from(privateKey1);
     } catch (err) {
       doDebug4 && console.log(privateKey);
       throw err;
     }
-  } else if (privateKey instanceof KeyObject4) {
+  } else if (isKeyObject(privateKey)) {
     return privateKey;
   }
   throw new Error("Invalid privateKey");
 }
 
+// source/x509/_build_public_key.ts
+async function buildPublicKey(privateKey) {
+  const crypto3 = getCrypto();
+  const jwk = await crypto3.subtle.exportKey("jwk", privateKey);
+  delete jwk.d;
+  delete jwk.dp;
+  delete jwk.dq;
+  delete jwk.q;
+  delete jwk.qi;
+  jwk.key_ops = [
+    "encrypt",
+    "sign"
+    // "wrapKey"
+  ];
+  const publicKey = await crypto3.subtle.importKey("jwk", jwk, { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-256" } }, true, [
+    //   "encrypt",
+    //     "sign",
+    // "wrapKey",
+  ]);
+  return publicKey;
+}
+
 // source/x509/_get_attributes.ts
 var keyUsageApplication = x5092.KeyUsageFlags.keyEncipherment | x5092.KeyUsageFlags.nonRepudiation | x5092.KeyUsageFlags.dataEncipherment | x5092.KeyUsageFlags.keyCertSign | x5092.KeyUsageFlags.digitalSignature;
 var keyUsageCA = x5092.KeyUsageFlags.keyCertSign | x5092.KeyUsageFlags.cRLSign;
@@ -1891,19 +1946,19 @@ function getAttributes(purpose) {
   let keyUsageExtension = [];
   let usages;
   let nsComment;
-  let extension;
+  let _extension;
   switch (purpose) {
     case 1 /* ForCertificateAuthority */:
-      extension = "v3_ca";
+      _extension = "v3_ca";
       basicConstraints = new x5092.BasicConstraintsExtension(true, void 0, false);
       usages = keyUsageCA;
       keyUsageExtension = [];
       nsComment = "Self-signed certificate for CA generated by Node-OPCUA Certificate utility V2";
       break;
-    case 2 /* ForApplication */:
-    case 3 /* ForUserAuthentication */:
+    // case CertificatePurpose.ForApplication:
+    // case CertificatePurpose.ForUserAuthentication:
     default:
-      extension = "v3_selfsigned";
+      _extension = "v3_selfsigned";
       basicConstraints = new x5092.BasicConstraintsExtension(false, void 0, true);
       usages = keyUsageApplication;
       keyUsageExtension = [x5092.ExtendedKeyUsage.serverAuth, x5092.ExtendedKeyUsage.clientAuth];
@@ -1913,28 +1968,6 @@ function getAttributes(purpose) {
   return { nsComment, basicConstraints, keyUsageExtension, usages };
 }
 
-// source/x509/_build_public_key.ts
-async function buildPublicKey(privateKey) {
-  const crypto3 = getCrypto();
-  const jwk = await crypto3.subtle.exportKey("jwk", privateKey);
-  delete jwk.d;
-  delete jwk.dp;
-  delete jwk.dq;
-  delete jwk.q;
-  delete jwk.qi;
-  jwk.key_ops = [
-    "encrypt",
-    "sign"
-    // "wrapKey"
-  ];
-  const publicKey = await crypto3.subtle.importKey("jwk", jwk, { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-256" } }, true, [
-    //   "encrypt",
-    //     "sign",
-    // "wrapKey",
-  ]);
-  return publicKey;
-}
-
 // source/x509/create_certificate_signing_request.ts
 async function createCertificateSigningRequest({
   privateKey,
@@ -1958,9 +1991,15 @@ async function createCertificateSigningRequest({
     publicKey
   };
   const alternativeNameExtensions = [];
-  dns && dns.forEach((d) => alternativeNameExtensions.push({ type: "dns", value: d }));
-  ip && ip.forEach((d) => alternativeNameExtensions.push({ type: "ip", value: d }));
-  applicationUri && alternativeNameExtensions.push({ type: "url", value: applicationUri });
+  for (const d of dns ?? []) {
+    alternativeNameExtensions.push({ type: "dns", value: d });
+  }
+  for (const d of ip ?? []) {
+    alternativeNameExtensions.push({ type: "ip", value: d });
+  }
+  if (applicationUri) {
+    alternativeNameExtensions.push({ type: "url", value: applicationUri });
+  }
   const { basicConstraints, usages } = getAttributes(purpose);
   const s = new Subject(subject || "");
   const s1 = s.toStringInternal(", ");
@@ -6254,9 +6293,19 @@ async function createSelfSignedCertificate({
   }
   notAfter = notAfter || new Date(notBefore.getTime() + validity * 24 * 60 * 60 * 1e3);
   const alternativeNameExtensions = [];
-  dns && dns.forEach((d) => alternativeNameExtensions.push({ type: "dns", value: d }));
-  ip && ip.forEach((d) => alternativeNameExtensions.push({ type: "ip", value: d }));
-  applicationUri && alternativeNameExtensions.push({ type: "url", value: applicationUri });
+  if (dns) {
+    for (const d of dns) {
+      alternativeNameExtensions.push({ type: "dns", value: d });
+    }
+  }
+  if (ip) {
+    for (const d of ip) {
+      alternativeNameExtensions.push({ type: "ip", value: d });
+    }
+  }
+  if (applicationUri) {
+    alternativeNameExtensions.push({ type: "url", value: applicationUri });
+  }
   const ID_NETSCAPE_COMMENT = "2.16.840.1.113730.1.13";
   const s = new Subject(subject || "");
   const s1 = s.toStringInternal(", ");
@@ -6290,11 +6339,9 @@ var asn1 = { readDirectoryName, readTag, readStruct, readAlgorithmIdentifier, re
 
 export {
   __dirname,
-  readExtension,
-  readTbsCertificate,
-  exploreCertificate,
-  split_der,
-  combine_der,
+  createPrivateKeyFromNodeJSCrypto,
+  isKeyObject,
+  CertificatePurpose,
   identifyPemType,
   removeTrailingLF,
   toPem,
@@ -6315,12 +6362,11 @@ export {
   coerceCertificatePem,
   extractPublicKeyFromCertificateSync,
   extractPublicKeyFromCertificate,
-  explorePrivateKey,
-  publicKeyAndPrivateKeyMatches,
-  certificateMatchesPrivateKey,
-  createPrivateKeyFromNodeJSCrypto,
-  isKeyObject,
-  CertificatePurpose,
+  readExtension,
+  readTbsCertificate,
+  exploreCertificate,
+  split_der,
+  combine_der,
   rsaLengthPrivateKey,
   toPem2,
   coercePrivateKeyPem,
@@ -6345,8 +6391,11 @@ export {
   exploreCertificateRevocationList,
   readCertificationRequestInfo,
   exploreCertificateSigningRequest,
+  explorePrivateKey,
   makePrivateKeyFromPem,
   makePrivateKeyThumbPrint,
+  publicKeyAndPrivateKeyMatches,
+  certificateMatchesPrivateKey,
   Subject,
   verifyCertificateOrClrSignature,
   verifyCertificateSignature,
@@ -6431,4 +6480,4 @@ asn1js/build/index.es.js:
    * 
    *)
 */
-//# sourceMappingURL=chunk-MGQCHN54.mjs.map
+//# sourceMappingURL=chunk-BIS3W2GR.mjs.map