node-opcua-crypto 4.11.0 → 4.12.0

package/dist/{chunk-2RCYFHGG.mjs → chunk-LHUQUHQQ.mjs}

@@ -323,33 +323,33 @@ var oid_map = {
 };
 
 // source/asn1.ts
-var TagType = /* @__PURE__ */ ((TagType3) => {
-  TagType3[TagType3["BOOLEAN"] = 1] = "BOOLEAN";
-  TagType3[TagType3["INTEGER"] = 2] = "INTEGER";
-  TagType3[TagType3["BIT_STRING"] = 3] = "BIT_STRING";
-  TagType3[TagType3["OCTET_STRING"] = 4] = "OCTET_STRING";
-  TagType3[TagType3["NULL"] = 5] = "NULL";
-  TagType3[TagType3["OBJECT_IDENTIFIER"] = 6] = "OBJECT_IDENTIFIER";
-  TagType3[TagType3["UTF8String"] = 12] = "UTF8String";
-  TagType3[TagType3["NumericString"] = 18] = "NumericString";
-  TagType3[TagType3["PrintableString"] = 19] = "PrintableString";
-  TagType3[TagType3["TeletexString"] = 20] = "TeletexString";
-  TagType3[TagType3["IA5String"] = 22] = "IA5String";
-  TagType3[TagType3["UTCTime"] = 23] = "UTCTime";
-  TagType3[TagType3["GeneralizedTime"] = 24] = "GeneralizedTime";
-  TagType3[TagType3["GraphicString"] = 25] = "GraphicString";
-  TagType3[TagType3["VisibleString"] = 26] = "VisibleString";
-  TagType3[TagType3["GeneralString"] = 27] = "GeneralString";
-  TagType3[TagType3["UniversalString"] = 28] = "UniversalString";
-  TagType3[TagType3["BMPString"] = 30] = "BMPString";
-  TagType3[TagType3["SEQUENCE"] = 48] = "SEQUENCE";
-  TagType3[TagType3["SET"] = 49] = "SET";
-  TagType3[TagType3["CONTEXT_SPECIFIC0"] = 160] = "CONTEXT_SPECIFIC0";
-  TagType3[TagType3["CONTEXT_SPECIFIC1"] = 161] = "CONTEXT_SPECIFIC1";
-  TagType3[TagType3["CONTEXT_SPECIFIC2"] = 162] = "CONTEXT_SPECIFIC2";
-  TagType3[TagType3["CONTEXT_SPECIFIC3"] = 163] = "CONTEXT_SPECIFIC3";
-  TagType3[TagType3["A4"] = 164] = "A4";
-  return TagType3;
+var TagType = /* @__PURE__ */ ((TagType2) => {
+  TagType2[TagType2["BOOLEAN"] = 1] = "BOOLEAN";
+  TagType2[TagType2["INTEGER"] = 2] = "INTEGER";
+  TagType2[TagType2["BIT_STRING"] = 3] = "BIT_STRING";
+  TagType2[TagType2["OCTET_STRING"] = 4] = "OCTET_STRING";
+  TagType2[TagType2["NULL"] = 5] = "NULL";
+  TagType2[TagType2["OBJECT_IDENTIFIER"] = 6] = "OBJECT_IDENTIFIER";
+  TagType2[TagType2["UTF8String"] = 12] = "UTF8String";
+  TagType2[TagType2["NumericString"] = 18] = "NumericString";
+  TagType2[TagType2["PrintableString"] = 19] = "PrintableString";
+  TagType2[TagType2["TeletexString"] = 20] = "TeletexString";
+  TagType2[TagType2["IA5String"] = 22] = "IA5String";
+  TagType2[TagType2["UTCTime"] = 23] = "UTCTime";
+  TagType2[TagType2["GeneralizedTime"] = 24] = "GeneralizedTime";
+  TagType2[TagType2["GraphicString"] = 25] = "GraphicString";
+  TagType2[TagType2["VisibleString"] = 26] = "VisibleString";
+  TagType2[TagType2["GeneralString"] = 27] = "GeneralString";
+  TagType2[TagType2["UniversalString"] = 28] = "UniversalString";
+  TagType2[TagType2["BMPString"] = 30] = "BMPString";
+  TagType2[TagType2["SEQUENCE"] = 48] = "SEQUENCE";
+  TagType2[TagType2["SET"] = 49] = "SET";
+  TagType2[TagType2["CONTEXT_SPECIFIC0"] = 160] = "CONTEXT_SPECIFIC0";
+  TagType2[TagType2["CONTEXT_SPECIFIC1"] = 161] = "CONTEXT_SPECIFIC1";
+  TagType2[TagType2["CONTEXT_SPECIFIC2"] = 162] = "CONTEXT_SPECIFIC2";
+  TagType2[TagType2["CONTEXT_SPECIFIC3"] = 163] = "CONTEXT_SPECIFIC3";
+  TagType2[TagType2["A4"] = 164] = "A4";
+  return TagType2;
 })(TagType || {});
 function readTag(buf, pos) {
   const start = pos;
@@ -395,9 +395,9 @@ function parseBitString(buffer, start, end, maxLength) {
   }
   return intro + s;
 }
-function _readBitString(buffer, block) {
+function readBitString(buffer, block) {
   assert(block.tag === 3 /* BIT_STRING */);
-  const data = _getBlock(buffer, block);
+  const data = getBlock(buffer, block);
   const ignore_bits = data.readUInt8(0);
   return {
     lengthInBits: data.length * 8 - ignore_bits,
@@ -413,7 +413,7 @@ function formatBuffer2DigitHexWithColum(buffer) {
   }
   return value.join(":").toUpperCase().replace(/^(00:)*/, "");
 }
-function _readOctetString(buffer, block) {
+function readOctetString(buffer, block) {
   assert(block.tag === 4 /* OCTET_STRING */);
   const tag = readTag(buffer, block.position);
   assert(tag.tag === 4 /* OCTET_STRING */);
@@ -422,19 +422,19 @@ function _readOctetString(buffer, block) {
   const b = buffer.subarray(pos, pos + nbBytes);
   return b;
 }
-function _getBlock(buffer, block) {
+function getBlock(buffer, block) {
   const start = block.position;
   const end = block.position + block.length;
   return buffer.subarray(start, end);
 }
-function _readIntegerAsByteString(buffer, block) {
-  return _getBlock(buffer, block);
+function readIntegerAsByteString(buffer, block) {
+  return getBlock(buffer, block);
 }
-function _readListOfInteger(buffer) {
+function readListOfInteger(buffer) {
   const block = readTag(buffer, 0);
   const inner_blocks = readStruct(buffer, block);
   return inner_blocks.map((innerBlock) => {
-    return _readIntegerAsByteString(buffer, innerBlock);
+    return readIntegerAsByteString(buffer, innerBlock);
   });
 }
 function parseOID(buffer, start, end) {
@@ -457,7 +457,7 @@ function parseOID(buffer, start, end) {
   assert(bits === 0);
   return s;
 }
-function _readObjectIdentifier(buffer, block) {
+function readObjectIdentifier(buffer, block) {
   assert(block.tag === 6 /* OBJECT_IDENTIFIER */);
   const b = buffer.subarray(block.position, block.position + block.length);
   const oid = parseOID(b, 0, block.length);
@@ -469,30 +469,30 @@ function _readObjectIdentifier(buffer, block) {
 function readAlgorithmIdentifier(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
   return {
-    identifier: _readObjectIdentifier(buffer, inner_blocks[0]).name
+    identifier: readObjectIdentifier(buffer, inner_blocks[0]).name
   };
 }
-function _readECCAlgorithmIdentifier(buffer, block) {
+function readECCAlgorithmIdentifier(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
   return {
-    identifier: _readObjectIdentifier(buffer, inner_blocks[1]).name
+    identifier: readObjectIdentifier(buffer, inner_blocks[1]).name
     // difference with RSA as algorithm is second element of nested block
   };
 }
 function readSignatureValueBin(buffer, block) {
-  return _readBitString(buffer, block).data;
+  return readBitString(buffer, block).data;
 }
 function readSignatureValue(buffer, block) {
   return readSignatureValueBin(buffer, block).toString("hex");
 }
-function _readLongIntegerValue(buffer, block) {
+function readLongIntegerValue(buffer, block) {
   assert(block.tag === 2 /* INTEGER */, "expecting a INTEGER tag");
   const pos = block.position;
   const nbBytes = block.length;
   const buf = buffer.subarray(pos, pos + nbBytes);
   return buf;
 }
-function _readIntegerValue(buffer, block) {
+function readIntegerValue(buffer, block) {
   assert(block.tag === 2 /* INTEGER */, "expecting a INTEGER tag");
   let pos = block.position;
   const nbBytes = block.length;
@@ -504,7 +504,7 @@ function _readIntegerValue(buffer, block) {
   }
   return value;
 }
-function _readBooleanValue(buffer, block) {
+function readBooleanValue(buffer, block) {
   assert(block.tag === 1 /* BOOLEAN */, "expecting a BOOLEAN tag. got " + TagType[block.tag]);
   const pos = block.position;
   const nbBytes = block.length;
@@ -512,9 +512,9 @@ function _readBooleanValue(buffer, block) {
   const value = buffer.readUInt8(pos) ? true : false;
   return value;
 }
-function _readVersionValue(buffer, block) {
+function readVersionValue(buffer, block) {
   block = readTag(buffer, block.position);
-  return _readIntegerValue(buffer, block);
+  return readIntegerValue(buffer, block);
 }
 function convertGeneralizedTime(str) {
   const year = parseInt(str.substr(0, 4), 10);
@@ -526,7 +526,7 @@ function convertGeneralizedTime(str) {
   return new Date(Date.UTC(year, month, day, hours, mins, secs));
 }
 function _readBMPString(buffer, block) {
-  const strBuff = _getBlock(buffer, block);
+  const strBuff = getBlock(buffer, block);
   let str = "";
   for (let i = 0; i < strBuff.length; i += 2) {
     const word = strBuff.readUInt16BE(i);
@@ -544,10 +544,10 @@ function convertUTCTime(str) {
   year += year >= 50 ? 1900 : 2e3;
   return new Date(Date.UTC(year, month, day, hours, mins, secs));
 }
-function _readValue(buffer, block) {
+function readValue(buffer, block) {
   switch (block.tag) {
     case 1 /* BOOLEAN */:
-      return _readBooleanValue(buffer, block);
+      return readBooleanValue(buffer, block);
     case 30 /* BMPString */:
       return _readBMPString(buffer, block);
     case 19 /* PrintableString */:
@@ -555,44 +555,29 @@ function _readValue(buffer, block) {
     case 12 /* UTF8String */:
     case 18 /* NumericString */:
     case 22 /* IA5String */:
-      return _getBlock(buffer, block).toString("ascii");
+      return getBlock(buffer, block).toString("ascii");
     case 23 /* UTCTime */:
-      return convertUTCTime(_getBlock(buffer, block).toString("ascii"));
+      return convertUTCTime(getBlock(buffer, block).toString("ascii"));
     case 24 /* GeneralizedTime */:
-      return convertGeneralizedTime(_getBlock(buffer, block).toString("ascii"));
+      return convertGeneralizedTime(getBlock(buffer, block).toString("ascii"));
     default:
       throw new Error("Invalid tag 0x" + block.tag.toString(16));
   }
 }
-function _readDirectoryName(buffer, block) {
-  const set_blocks = readStruct(buffer, block);
-  const names = {};
-  for (const set_block of set_blocks) {
-    assert(set_block.tag === 49);
-    const blocks = readStruct(buffer, set_block);
-    assert(blocks.length === 1);
-    assert(blocks[0].tag === 48);
-    const sequenceBlock = readStruct(buffer, blocks[0]);
-    assert(sequenceBlock.length === 2);
-    const type = _readObjectIdentifier(buffer, sequenceBlock[0]);
-    names[type.name] = _readValue(buffer, sequenceBlock[1]);
-  }
-  return names;
-}
-function _findBlockAtIndex(blocks, index) {
+function findBlockAtIndex(blocks, index) {
   const tmp = blocks.filter((b) => b.tag === 160 + index || b.tag === 128 + index);
   if (tmp.length === 0) {
     return null;
   }
   return tmp[0];
 }
-function _readTime(buffer, block) {
-  return _readValue(buffer, block);
+function readTime(buffer, block) {
+  return readValue(buffer, block);
 }
 
 // source/crypto_utils.ts
 import constants from "constants";
-import assert3 from "assert";
+import assert4 from "assert";
 import {
   createHash,
   createSign,
@@ -608,14 +593,34 @@ var createFastUninitializedBuffer = Buffer.allocUnsafe ? Buffer.allocUnsafe : (s
 };
 
 // source/crypto_explore_certificate.ts
+import assert3 from "assert";
+
+// source/directory_name.ts
 import assert2 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);
+    const blocks = readStruct(buffer, set_block);
+    assert2(blocks.length === 1);
+    assert2(blocks[0].tag === 48);
+    const sequenceBlock = readStruct(buffer, blocks[0]);
+    assert2(sequenceBlock.length === 2);
+    const type = readObjectIdentifier(buffer, sequenceBlock[0]);
+    names[type.name] = readValue(buffer, sequenceBlock[1]);
+  }
+  return names;
+}
+
+// source/crypto_explore_certificate.ts
 var doDebug = false;
 function _readAttributeTypeAndValue(buffer, block) {
   let inner_blocks = readStruct(buffer, block);
   inner_blocks = readStruct(buffer, inner_blocks[0]);
   const data = {
-    identifier: _readObjectIdentifier(buffer, inner_blocks[0]).name,
-    value: _readValue(buffer, inner_blocks[1])
+    identifier: readObjectIdentifier(buffer, inner_blocks[0]).name,
+    value: readValue(buffer, inner_blocks[1])
   };
   const result = {};
   for (const [key, value] of Object.entries(data)) {
@@ -638,29 +643,29 @@ function _readName(buffer, block) {
 function _readValidity(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
   return {
-    notBefore: _readTime(buffer, inner_blocks[0]),
-    notAfter: _readTime(buffer, inner_blocks[1])
+    notBefore: readTime(buffer, inner_blocks[0]),
+    notAfter: readTime(buffer, inner_blocks[1])
   };
 }
 function _readAuthorityKeyIdentifier(buffer) {
   const block_info = readTag(buffer, 0);
   const blocks = readStruct(buffer, block_info);
-  const keyIdentifier_block = _findBlockAtIndex(blocks, 0);
-  const authorityCertIssuer_block = _findBlockAtIndex(blocks, 1);
-  const authorityCertSerialNumber_block = _findBlockAtIndex(blocks, 2);
+  const keyIdentifier_block = findBlockAtIndex(blocks, 0);
+  const authorityCertIssuer_block = findBlockAtIndex(blocks, 1);
+  const authorityCertSerialNumber_block = findBlockAtIndex(blocks, 2);
   function _readAuthorityCertIssuer(block) {
     const inner_blocks = readStruct(buffer, block);
-    const directoryName_block = _findBlockAtIndex(inner_blocks, 4);
+    const directoryName_block = findBlockAtIndex(inner_blocks, 4);
     if (directoryName_block) {
       const a = readStruct(buffer, directoryName_block);
-      return _readDirectoryName(buffer, a[0]);
+      return readDirectoryName(buffer, a[0]);
     } else {
       throw new Error("Invalid _readAuthorityCertIssuer");
     }
   }
   function _readAuthorityCertIssuerFingerPrint(block) {
     const inner_blocks = readStruct(buffer, block);
-    const directoryName_block = _findBlockAtIndex(inner_blocks, 4);
+    const directoryName_block = findBlockAtIndex(inner_blocks, 4);
     if (!directoryName_block) {
       return "";
     }
@@ -668,16 +673,16 @@ function _readAuthorityKeyIdentifier(buffer) {
     if (a.length < 1) {
       return "";
     }
-    return directoryName_block ? formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, a[0]))) : "";
+    return directoryName_block ? formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(getBlock(buffer, a[0]))) : "";
   }
   const authorityCertIssuer = authorityCertIssuer_block ? _readAuthorityCertIssuer(authorityCertIssuer_block) : null;
   const authorityCertIssuerFingerPrint = authorityCertIssuer_block ? _readAuthorityCertIssuerFingerPrint(authorityCertIssuer_block) : "";
   return {
     authorityCertIssuer,
     authorityCertIssuerFingerPrint,
-    serial: authorityCertSerialNumber_block ? formatBuffer2DigitHexWithColum(_getBlock(buffer, authorityCertSerialNumber_block)) : null,
+    serial: authorityCertSerialNumber_block ? formatBuffer2DigitHexWithColum(getBlock(buffer, authorityCertSerialNumber_block)) : null,
     // can be null for self-signed cert
-    keyIdentifier: keyIdentifier_block ? formatBuffer2DigitHexWithColum(_getBlock(buffer, keyIdentifier_block)) : null
+    keyIdentifier: keyIdentifier_block ? formatBuffer2DigitHexWithColum(getBlock(buffer, keyIdentifier_block)) : null
     // can be null for self-signed certf
   };
 }
@@ -690,10 +695,10 @@ function readBasicConstraint2_5_29_19(buffer, block) {
   for (const inner_block of inner_blocks) {
     switch (inner_block.tag) {
       case 1 /* BOOLEAN */:
-        cA = _readBooleanValue(buffer, inner_block);
+        cA = readBooleanValue(buffer, inner_block);
         break;
       case 2 /* INTEGER */:
-        pathLengthConstraint = _readIntegerValue(buffer, inner_block);
+        pathLengthConstraint = readIntegerValue(buffer, inner_block);
         breakControl = 1;
         break;
     }
@@ -726,7 +731,7 @@ function _readGeneralNames(buffer, block) {
   }
   const n = {};
   for (const block2 of blocks) {
-    assert2((block2.tag & 128) === 128);
+    assert3((block2.tag & 128) === 128);
     const t2 = block2.tag & 127;
     const type = _data[t2];
     if (!type) {
@@ -736,10 +741,10 @@ function _readGeneralNames(buffer, block) {
     if (t2 == 32) {
       n[type.name] = n[type.name] || [];
       const blocks2 = readStruct(buffer, block2);
-      const name = _readObjectIdentifier(buffer, blocks2[0]).name;
-      const buf = _getBlock(buffer, blocks2[1]);
+      const name = readObjectIdentifier(buffer, blocks2[0]).name;
+      const buf = getBlock(buffer, blocks2[1]);
       const b = readTag(buf, 0);
-      const nn = _readValue(buf, b);
+      const nn = readValue(buf, b);
       const data = {
         identifier: name,
         value: nn
@@ -786,7 +791,7 @@ function readKeyUsage(oid, buffer) {
   };
 }
 function readExtKeyUsage(oid, buffer) {
-  assert2(oid === "2.5.29.37");
+  assert3(oid === "2.5.29.37");
   const block_info = readTag(buffer, 0);
   const inner_blocks = readStruct(buffer, block_info);
   const extKeyUsage = {
@@ -801,7 +806,7 @@ function readExtKeyUsage(oid, buffer) {
     ocspSigning: false
   };
   for (const block of inner_blocks) {
-    const identifier = _readObjectIdentifier(buffer, block);
+    const identifier = readObjectIdentifier(buffer, block);
     extKeyUsage[identifier.name] = true;
   }
   return extKeyUsage;
@@ -813,18 +818,18 @@ function _readSubjectPublicKey(buffer) {
     modulus: buffer.subarray(blocks[0].position + 1, blocks[0].position + blocks[0].length)
   };
 }
-function _readExtension(buffer, block) {
+function readExtension(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
   if (inner_blocks.length === 3) {
-    assert2(inner_blocks[1].tag === 1 /* BOOLEAN */);
+    assert3(inner_blocks[1].tag === 1 /* BOOLEAN */);
     inner_blocks[1] = inner_blocks[2];
   }
-  const identifier = _readObjectIdentifier(buffer, inner_blocks[0]);
-  const buf = _getBlock(buffer, inner_blocks[1]);
+  const identifier = readObjectIdentifier(buffer, inner_blocks[0]);
+  const buf = getBlock(buffer, inner_blocks[1]);
   let value = null;
   switch (identifier.name) {
     case "subjectKeyIdentifier":
-      value = formatBuffer2DigitHexWithColum(_readOctetString(buffer, inner_blocks[1]));
+      value = formatBuffer2DigitHexWithColum(readOctetString(buffer, inner_blocks[1]));
       break;
     case "subjectAltName":
       value = _readSubjectAltNames(buf);
@@ -853,10 +858,10 @@ function _readExtension(buffer, block) {
   };
 }
 function _readExtensions(buffer, block) {
-  assert2(block.tag === 163);
+  assert3(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));
+  const extensions = inner_blocks.map((block2) => readExtension(buffer, block2));
   const result = {};
   for (const e of extensions) {
     result[e.identifier.name] = e.value;
@@ -866,9 +871,9 @@ function _readExtensions(buffer, block) {
 function _readSubjectPublicKeyInfo(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
   const algorithm = readAlgorithmIdentifier(buffer, inner_blocks[0]);
-  const subjectPublicKey = _readBitString(buffer, inner_blocks[1]);
+  const subjectPublicKey = readBitString(buffer, inner_blocks[1]);
   const data = subjectPublicKey.data;
-  const values = _readListOfInteger(data);
+  const values = readListOfInteger(data);
   return {
     algorithm: algorithm.identifier,
     keyLength: values[0].length - 1,
@@ -879,8 +884,8 @@ function _readSubjectPublicKeyInfo(buffer, block) {
 }
 function _readSubjectECCPublicKeyInfo(buffer, block) {
   const inner_blocks = readStruct(buffer, block);
-  const algorithm = _readECCAlgorithmIdentifier(buffer, inner_blocks[0]);
-  const subjectPublicKey = _readBitString(buffer, inner_blocks[1]);
+  const algorithm = readECCAlgorithmIdentifier(buffer, inner_blocks[0]);
+  const subjectPublicKey = readBitString(buffer, inner_blocks[1]);
   const data = subjectPublicKey.data;
   return {
     algorithm: algorithm.identifier,
@@ -896,26 +901,26 @@ function readTbsCertificate(buffer, block) {
   let subjectPublicKeyInfo;
   if (blocks.length === 6) {
     version = 1;
-    serialNumber = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, blocks[0]));
+    serialNumber = formatBuffer2DigitHexWithColum(readLongIntegerValue(buffer, blocks[0]));
     signature = readAlgorithmIdentifier(buffer, blocks[1]);
     issuer = _readName(buffer, blocks[2]);
     validity = _readValidity(buffer, blocks[3]);
     subject = _readName(buffer, blocks[4]);
-    subjectFingerPrint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, blocks[4])));
+    subjectFingerPrint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(getBlock(buffer, blocks[4])));
     subjectPublicKeyInfo = _readSubjectPublicKeyInfo(buffer, blocks[5]);
     extensions = null;
   } else {
-    const version_block = _findBlockAtIndex(blocks, 0);
+    const version_block = findBlockAtIndex(blocks, 0);
     if (!version_block) {
       throw new Error("cannot find version block");
     }
-    version = _readVersionValue(buffer, version_block) + 1;
-    serialNumber = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, blocks[1]));
+    version = readVersionValue(buffer, version_block) + 1;
+    serialNumber = formatBuffer2DigitHexWithColum(readLongIntegerValue(buffer, blocks[1]));
     signature = readAlgorithmIdentifier(buffer, blocks[2]);
     issuer = _readName(buffer, blocks[3]);
     validity = _readValidity(buffer, blocks[4]);
     subject = _readName(buffer, blocks[5]);
-    subjectFingerPrint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, blocks[5])));
+    subjectFingerPrint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(getBlock(buffer, blocks[5])));
     const inner_block = readStruct(buffer, blocks[6]);
     const what_type = readAlgorithmIdentifier(buffer, inner_block[0]).identifier;
     switch (what_type) {
@@ -929,7 +934,7 @@ function readTbsCertificate(buffer, block) {
         break;
       }
     }
-    const extensionBlock = _findBlockAtIndex(blocks, 3);
+    const extensionBlock = findBlockAtIndex(blocks, 3);
     if (!extensionBlock) {
       doDebug && console.log("X509 certificate is invalid : cannot find extension block version =" + version_block);
       extensions = null;
@@ -950,7 +955,7 @@ function readTbsCertificate(buffer, block) {
   };
 }
 function exploreCertificate(certificate) {
-  assert2(certificate instanceof Buffer);
+  assert3(certificate instanceof Buffer);
   if (!certificate._exploreCertificate_cache) {
     const block_info = readTag(certificate, 0);
     const blocks = readStruct(certificate, block_info);
@@ -979,10 +984,10 @@ function combine_der(certificates) {
     let sum = 0;
     b.forEach((block) => {
       const block_info = readTag(block, 0);
-      assert2(block_info.position + block_info.length === block.length);
+      assert3(block_info.position + block_info.length === block.length);
       sum += block.length;
     });
-    assert2(sum === cert.length);
+    assert3(sum === cert.length);
   }
   return Buffer.concat(certificates);
 }
@@ -1004,14 +1009,14 @@ function removeTrailingLF(str) {
   return tmp;
 }
 function toPem(raw_key, pem) {
-  assert3(raw_key, "expecting a key");
-  assert3(typeof pem === "string");
+  assert4(raw_key, "expecting a key");
+  assert4(typeof pem === "string");
   let pemType = identifyPemType(raw_key);
   if (pemType) {
     return raw_key instanceof Buffer ? removeTrailingLF(raw_key.toString("utf8")) : removeTrailingLF(raw_key);
   } else {
     pemType = pem;
-    assert3(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
+    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) {
@@ -1051,7 +1056,7 @@ function makeMessageChunkSignature(chunk, options) {
   const signer = createSign(options.algorithm);
   signer.update(chunk);
   const signature = signer.sign(options.privateKey.hidden);
-  assert3(!options.signatureLength || signature.length === options.signatureLength);
+  assert4(!options.signatureLength || signature.length === options.signatureLength);
   return signature;
 }
 function verifyMessageChunkSignature(blockToVerify, signature, options) {
@@ -1069,8 +1074,8 @@ var PaddingAlgorithm = /* @__PURE__ */ ((PaddingAlgorithm2) => {
   PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_PADDING"] = 1] = "RSA_PKCS1_PADDING";
   return PaddingAlgorithm2;
 })(PaddingAlgorithm || {});
-assert3(4 /* RSA_PKCS1_OAEP_PADDING */ === constants.RSA_PKCS1_OAEP_PADDING);
-assert3(1 /* RSA_PKCS1_PADDING */ === constants.RSA_PKCS1_PADDING);
+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 */;
@@ -1147,14 +1152,14 @@ function coerceCertificatePem(certificate) {
   if (certificate instanceof Buffer) {
     certificate = toPem(certificate, "CERTIFICATE");
   }
-  assert3(typeof certificate === "string");
+  assert4(typeof certificate === "string");
   return certificate;
 }
 function extractPublicKeyFromCertificateSync(certificate) {
   certificate = coerceCertificatePem(certificate);
   const key = jsrsasign.KEYUTIL.getKey(certificate);
   const publicKeyAsPem = jsrsasign.KEYUTIL.getPEM(key);
-  assert3(typeof publicKeyAsPem === "string");
+  assert4(typeof publicKeyAsPem === "string");
   return publicKeyAsPem;
 }
 function extractPublicKeyFromCertificate(certificate, callback) {
@@ -1290,7 +1295,7 @@ var CertificatePurpose = /* @__PURE__ */ ((CertificatePurpose2) => {
 })(CertificatePurpose || {});
 
 // source/crypto_utils2.ts
-import assert4 from "assert";
+import assert5 from "assert";
 import jsrsasign2 from "jsrsasign";
 function rsaLengthPrivateKey(key) {
   const keyPem = typeof key.hidden === "string" ? key.hidden : key.hidden.export({ type: "pkcs1", format: "pem" }).toString();
@@ -1301,8 +1306,8 @@ function toPem2(raw_key, pem) {
   if (raw_key.hidden) {
     return toPem2(raw_key.hidden, pem);
   }
-  assert4(raw_key, "expecting a key");
-  assert4(typeof pem === "string");
+  assert5(raw_key, "expecting a key");
+  assert5(typeof pem === "string");
   if (isKeyObject(raw_key)) {
     const _raw_key = raw_key;
     if (pem === "RSA PRIVATE KEY") {
@@ -1322,40 +1327,40 @@ function coercePublicKeyPem(publicKey) {
   if (isKeyObject(publicKey)) {
     return publicKey.export({ format: "pem", type: "spki" }).toString();
   }
-  assert4(typeof publicKey === "string");
+  assert5(typeof publicKey === "string");
   return publicKey;
 }
 function coerceRsaPublicKeyPem(publicKey) {
   if (isKeyObject(publicKey)) {
     return publicKey.export({ format: "pem", type: "spki" }).toString();
   }
-  assert4(typeof publicKey === "string");
+  assert5(typeof publicKey === "string");
   return publicKey;
 }
 function rsaLengthPublicKey(key) {
   key = coercePublicKeyPem(key);
-  assert4(typeof key === "string");
+  assert5(typeof key === "string");
   const a = jsrsasign2.KEYUTIL.getKey(key);
   return a.n.toString(16).length / 2;
 }
 function rsaLengthRsaPublicKey(key) {
   key = coerceRsaPublicKeyPem(key);
-  assert4(typeof key === "string");
+  assert5(typeof key === "string");
   const a = jsrsasign2.KEYUTIL.getKey(key);
   return a.n.toString(16).length / 2;
 }
 
 // source/derived_keys.ts
-import assert6 from "assert";
+import assert7 from "assert";
 import { createCipheriv, createDecipheriv, createHmac } from "crypto";
 
 // source/explore_certificate.ts
-import assert5 from "assert";
+import assert6 from "assert";
 function coerceCertificate(certificate) {
   if (typeof certificate === "string") {
     certificate = convertPEMtoDER(certificate);
   }
-  assert5(certificate instanceof Buffer);
+  assert6(certificate instanceof Buffer);
   return certificate;
 }
 function exploreCertificateInfo(certificate) {
@@ -1382,8 +1387,8 @@ function plus(buf1, buf2) {
   return Buffer.concat([buf1, buf2]);
 }
 function makePseudoRandomBuffer(secret, seed, minLength, sha1or256) {
-  assert6(seed instanceof Buffer);
-  assert6(sha1or256 === "SHA1" || sha1or256 === "SHA256");
+  assert7(seed instanceof Buffer);
+  assert7(sha1or256 === "SHA1" || sha1or256 === "SHA256");
   const a = [];
   a[0] = seed;
   let index = 1;
@@ -1396,12 +1401,12 @@ function makePseudoRandomBuffer(secret, seed, minLength, sha1or256) {
   return p_hash.subarray(0, minLength);
 }
 function computeDerivedKeys(secret, seed, options) {
-  assert6(Number.isFinite(options.signatureLength));
-  assert6(Number.isFinite(options.encryptingKeyLength));
-  assert6(Number.isFinite(options.encryptingBlockSize));
-  assert6(typeof options.algorithm === "string");
+  assert7(Number.isFinite(options.signatureLength));
+  assert7(Number.isFinite(options.encryptingKeyLength));
+  assert7(Number.isFinite(options.encryptingBlockSize));
+  assert7(typeof options.algorithm === "string");
   options.sha1or256 = options.sha1or256 || "SHA1";
-  assert6(typeof options.sha1or256 === "string");
+  assert7(typeof options.sha1or256 === "string");
   const offset1 = options.signingKeyLength;
   const offset2 = offset1 + options.encryptingKeyLength;
   const minLength = offset2 + options.encryptingBlockSize;
@@ -1426,7 +1431,7 @@ function removePadding(buffer) {
   return reduceLength(buffer, nbPaddingBytes);
 }
 function verifyChunkSignature(chunk, options) {
-  assert6(chunk instanceof Buffer);
+  assert7(chunk instanceof Buffer);
   let signatureLength = options.signatureLength || 0;
   if (signatureLength === 0) {
     const cert = exploreCertificateInfo(options.publicKey);
@@ -1437,16 +1442,16 @@ function verifyChunkSignature(chunk, options) {
   return verifyMessageChunkSignature(block_to_verify, signature, options);
 }
 function computePaddingFooter(buffer, derivedKeys) {
-  assert6(Object.prototype.hasOwnProperty.call(derivedKeys, "encryptingBlockSize"));
+  assert7(Object.prototype.hasOwnProperty.call(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) {
-  assert6(Object.prototype.hasOwnProperty.call(derivedKeys, "algorithm"));
+  assert7(Object.prototype.hasOwnProperty.call(derivedKeys, "algorithm"));
   const algorithm = derivedKeys.algorithm || "aes-128-cbc";
-  assert6(algorithm === "aes-128-cbc" || algorithm === "aes-256-cbc");
+  assert7(algorithm === "aes-128-cbc" || algorithm === "aes-256-cbc");
   return algorithm;
 }
 function encryptBufferWithDerivedKeys(buffer, derivedKeys) {
@@ -1472,12 +1477,12 @@ function decryptBufferWithDerivedKeys(buffer, derivedKeys) {
   return Buffer.concat(decrypted_chunks);
 }
 function makeMessageChunkSignatureWithDerivedKeys(message, derivedKeys) {
-  assert6(message instanceof Buffer);
-  assert6(derivedKeys.signingKey instanceof Buffer);
-  assert6(typeof derivedKeys.sha1or256 === "string");
-  assert6(derivedKeys.sha1or256 === "SHA1" || derivedKeys.sha1or256 === "SHA256");
+  assert7(message instanceof Buffer);
+  assert7(derivedKeys.signingKey instanceof Buffer);
+  assert7(typeof derivedKeys.sha1or256 === "string");
+  assert7(derivedKeys.sha1or256 === "SHA1" || derivedKeys.sha1or256 === "SHA256");
   const signature = createHmac(derivedKeys.sha1or256, derivedKeys.signingKey).update(message).digest();
-  assert6(signature.length === derivedKeys.signatureLength);
+  assert7(signature.length === derivedKeys.signatureLength);
   return signature;
 }
 function verifyChunkSignatureWithDerivedKeys(chunk, derivedKeys) {
@@ -1516,46 +1521,46 @@ function exploreAsn1(buffer) {
 
 // source/explore_certificate_revocation_list.ts
 function readNameForCrl(buffer, block) {
-  return _readDirectoryName(buffer, block);
+  return readDirectoryName(buffer, block);
 }
 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])));
-    const thisUpdate = _readTime(buffer, blocks[3]);
-    const nextUpdate = _readTime(buffer, blocks[4]);
+    const issuerFingerprint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(getBlock(buffer, blocks[2])));
+    const thisUpdate = readTime(buffer, blocks[3]);
+    const nextUpdate = readTime(buffer, blocks[4]);
     const revokedCertificates = [];
     if (blocks[5] && blocks[5].tag < 128) {
       const list = readStruct(buffer, blocks[5]);
       for (const r of list) {
         const rr = readStruct(buffer, r);
-        const userCertificate = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, rr[0]));
-        const revocationDate = _readTime(buffer, rr[1]);
+        const userCertificate = formatBuffer2DigitHexWithColum(readLongIntegerValue(buffer, rr[0]));
+        const revocationDate = readTime(buffer, rr[1]);
         revokedCertificates.push({
           revocationDate,
           userCertificate
         });
       }
     }
-    const ext0 = _findBlockAtIndex(blocks, 0);
+    const ext0 = findBlockAtIndex(blocks, 0);
     return { issuer, issuerFingerprint, thisUpdate, nextUpdate, signature, revokedCertificates };
   } else {
     const signature = readAlgorithmIdentifier(buffer, blocks[0]);
     const issuer = readNameForCrl(buffer, blocks[1]);
-    const issuerFingerprint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, blocks[1])));
-    const thisUpdate = _readTime(buffer, blocks[2]);
-    const nextUpdate = _readTime(buffer, blocks[3]);
+    const issuerFingerprint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(getBlock(buffer, blocks[1])));
+    const thisUpdate = readTime(buffer, blocks[2]);
+    const nextUpdate = readTime(buffer, blocks[3]);
     const revokedCertificates = [];
     if (blocks[4] && blocks[4].tag < 128) {
       const list = readStruct(buffer, blocks[4]);
       for (const r of list) {
         const rr = readStruct(buffer, r);
-        const userCertificate = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, rr[0]));
-        const revocationDate = _readTime(buffer, rr[1]);
+        const userCertificate = formatBuffer2DigitHexWithColum(readLongIntegerValue(buffer, rr[0]));
+        const revocationDate = readTime(buffer, rr[1]);
         revokedCertificates.push({
           revocationDate,
           userCertificate
@@ -1578,7 +1583,7 @@ function exploreCertificateRevocationList(crl) {
 function _readExtensionRequest(buffer) {
   const block = readTag(buffer, 0);
   const inner_blocks = readStruct(buffer, block);
-  const extensions = inner_blocks.map((block1) => _readExtension(buffer, block1));
+  const extensions = inner_blocks.map((block1) => readExtension(buffer, block1));
   const result = {};
   for (const e of extensions) {
     result[e.identifier.name] = e.value;
@@ -1589,17 +1594,17 @@ function _readExtensionRequest(buffer) {
 function readCertificationRequestInfo(buffer, block) {
   const blocks = readStruct(buffer, block);
   if (blocks.length === 4) {
-    const extensionRequestBlock = _findBlockAtIndex(blocks, 0);
+    const extensionRequestBlock = findBlockAtIndex(blocks, 0);
     if (!extensionRequestBlock) {
       throw new Error("cannot find extensionRequest block");
     }
     const blocks1 = readStruct(buffer, extensionRequestBlock);
     const blocks2 = readStruct(buffer, blocks1[0]);
-    const identifier = _readObjectIdentifier(buffer, blocks2[0]);
+    const identifier = readObjectIdentifier(buffer, blocks2[0]);
     if (identifier.name !== "extensionRequest") {
       throw new Error(" Cannot find extension Request in ASN1 block");
     }
-    const buf = _getBlock(buffer, blocks2[1]);
+    const buf = getBlock(buffer, blocks2[1]);
     const extensionRequest = _readExtensionRequest(buf);
     return { extensionRequest };
   }
@@ -5419,11 +5424,11 @@ function compareSchema(root, inputData, inputSchema) {
     };
   }
   if (inputSchema.primitiveSchema && VALUE_HEX_VIEW in inputData.valueBlock) {
-    const asn1 = localFromBER(inputData.valueBlock.valueHexView);
-    if (asn1.offset === -1) {
+    const asn12 = localFromBER(inputData.valueBlock.valueHexView);
+    if (asn12.offset === -1) {
       const _result = {
         verified: false,
-        result: asn1.result
+        result: asn12.result
       };
       if (inputSchema.name) {
         inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
@@ -5434,7 +5439,7 @@ function compareSchema(root, inputData, inputSchema) {
       }
       return _result;
     }
-    return compareSchema(root, asn1.result, inputSchema.primitiveSchema);
+    return compareSchema(root, asn12.result, inputSchema.primitiveSchema);
   }
   return {
     verified: true,
@@ -5448,14 +5453,14 @@ function verifySchema(inputBuffer, inputSchema) {
       result: { error: "Wrong ASN.1 schema type" }
     };
   }
-  const asn1 = localFromBER(BufferSourceConverter.toUint8Array(inputBuffer));
-  if (asn1.offset === -1) {
+  const asn12 = localFromBER(BufferSourceConverter.toUint8Array(inputBuffer));
+  if (asn12.offset === -1) {
     return {
       verified: false,
-      result: asn1.result
+      result: asn12.result
     };
   }
-  return compareSchema(asn1.result, asn1.result, inputSchema);
+  return compareSchema(asn12.result, asn12.result, inputSchema);
 }
 
 // ../../node_modules/@peculiar/asn1-schema/build/es2015/enums.js
@@ -6143,13 +6148,12 @@ async function createSelfSignedCertificate({
   return { cert: cert.toString("pem"), der: cert };
 }
 
+// source/index_web.ts
+var asn1 = { readDirectoryName, readTag, readStruct, readAlgorithmIdentifier, readSignatureValueBin };
+
 export {
   __dirname,
-  readTag,
-  readStruct,
-  readAlgorithmIdentifier,
-  readSignatureValueBin,
-  _readExtension,
+  readExtension,
   readTbsCertificate,
   exploreCertificate,
   split_der,
@@ -6219,7 +6223,8 @@ export {
   coercePEMorDerToPrivateKey,
   _coercePrivateKey,
   createCertificateSigningRequest,
-  createSelfSignedCertificate
+  createSelfSignedCertificate,
+  asn1
 };
 /*! Bundled license information:
 
@@ -6289,4 +6294,4 @@ asn1js/build/index.es.js:
    * 
    *)
 */
-//# sourceMappingURL=chunk-2RCYFHGG.mjs.map
+//# sourceMappingURL=chunk-LHUQUHQQ.mjs.map