web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/@peculiar/x509/build/x509.es.js

@@ -0,0 +1,2676 @@
+import '../../../../_virtual/Reflect.js';
+import { AsnUtf8StringConverter } from '../../asn1-schema/build/es2015/converters.js';
+import '../../../asn1js/build/index.es.js';
+import { b as buildExports } from '../../../../_virtual/index9.js';
+import { OctetString } from '../../asn1-schema/build/es2015/types/octet_string.js';
+import '../../asn1-schema/build/es2015/enums.js';
+import { AsnConvert } from '../../asn1-schema/build/es2015/convert.js';
+import { id_pe_authorityInfoAccess, AuthorityInfoAccessSyntax, AccessDescription } from '../../asn1-x509/build/es2015/extensions/authority_information_access.js';
+import { id_ce_authorityKeyIdentifier, AuthorityKeyIdentifier, KeyIdentifier } from '../../asn1-x509/build/es2015/extensions/authority_key_identifier.js';
+import { BasicConstraints, id_ce_basicConstraints } from '../../asn1-x509/build/es2015/extensions/basic_constraints.js';
+import '../../asn1-x509/build/es2015/extensions/certificate_issuer.js';
+import { id_ce_certificatePolicies, CertificatePolicies, PolicyInformation } from '../../asn1-x509/build/es2015/extensions/certificate_policies.js';
+import '../../asn1-x509/build/es2015/extensions/crl_delta_indicator.js';
+import { id_ce_cRLDistributionPoints, DistributionPoint, DistributionPointName, CRLDistributionPoints } from '../../asn1-x509/build/es2015/extensions/crl_distribution_points.js';
+import '../../asn1-x509/build/es2015/extensions/crl_freshest.js';
+import '../../asn1-x509/build/es2015/extensions/crl_issuing_distribution_point.js';
+import '../../asn1-x509/build/es2015/extensions/crl_number.js';
+import '../../asn1-x509/build/es2015/extensions/crl_reason.js';
+import { id_kp_OCSPSigning, id_kp_timeStamping, id_kp_emailProtection, id_kp_codeSigning, id_kp_clientAuth, id_kp_serverAuth, id_ce_extKeyUsage, ExtendedKeyUsage as ExtendedKeyUsage$1 } from '../../asn1-x509/build/es2015/extensions/extended_key_usage.js';
+import '../../asn1-x509/build/es2015/extensions/inhibit_any_policy.js';
+import '../../asn1-x509/build/es2015/extensions/invalidity_date.js';
+import '../../asn1-x509/build/es2015/extensions/issuer_alternative_name.js';
+import { id_ce_keyUsage, KeyUsage } from '../../asn1-x509/build/es2015/extensions/key_usage.js';
+import '../../asn1-x509/build/es2015/extensions/name_constraints.js';
+import '../../asn1-x509/build/es2015/extensions/policy_constraints.js';
+import '../../asn1-x509/build/es2015/extensions/policy_mappings.js';
+import { id_ce_subjectAltName, SubjectAlternativeName } from '../../asn1-x509/build/es2015/extensions/subject_alternative_name.js';
+import '../../asn1-x509/build/es2015/extensions/subject_directory_attributes.js';
+import { id_ce_subjectKeyIdentifier, SubjectKeyIdentifier } from '../../asn1-x509/build/es2015/extensions/subject_key_identifier.js';
+import '../../asn1-x509/build/es2015/extensions/private_key_usage_period.js';
+import '../../asn1-x509/build/es2015/extensions/entrust_version_info.js';
+import '../../asn1-x509/build/es2015/extensions/subject_info_access.js';
+import { AlgorithmIdentifier } from '../../asn1-x509/build/es2015/algorithm_identifier.js';
+import { Attribute as Attribute$1 } from '../../asn1-x509/build/es2015/attribute.js';
+import { Certificate } from '../../asn1-x509/build/es2015/certificate.js';
+import '../../asn1-x509/build/es2015/certificate_list.js';
+import { Extensions, Extension as Extension$1 } from '../../asn1-x509/build/es2015/extension.js';
+import { GeneralName as GeneralName$1, OtherName } from '../../asn1-x509/build/es2015/general_name.js';
+import { GeneralNames as GeneralNames$1 } from '../../asn1-x509/build/es2015/general_names.js';
+import { Name as Name$1, RelativeDistinguishedName, AttributeTypeAndValue, DirectoryString } from '../../asn1-x509/build/es2015/name.js';
+import { id_ad_caRepository, id_ad_timeStamping, id_ad_caIssuers, id_ad_ocsp } from '../../asn1-x509/build/es2015/object_identifiers.js';
+import { SubjectPublicKeyInfo } from '../../asn1-x509/build/es2015/subject_public_key_info.js';
+import '../../asn1-x509/build/es2015/tbs_cert_list.js';
+import { TBSCertificate } from '../../asn1-x509/build/es2015/tbs_certificate.js';
+import '../../asn1-x509/build/es2015/time.js';
+import { Version } from '../../asn1-x509/build/es2015/types.js';
+import { Validity } from '../../asn1-x509/build/es2015/validity.js';
+import '../../asn1-cms/build/es2015/attributes.js';
+import '../../asn1-cms/build/es2015/attribute.js';
+import '../../asn1-cms/build/es2015/certificate_choices.js';
+import '../../asn1-cms/build/es2015/content_info.js';
+import '../../asn1-cms/build/es2015/encapsulated_content_info.js';
+import '../../asn1-cms/build/es2015/encrypted_content_info.js';
+import '../../asn1-cms/build/es2015/enveloped_data.js';
+import '../../asn1-cms/build/es2015/issuer_and_serial_number.js';
+import '../../asn1-cms/build/es2015/kek_recipient_info.js';
+import '../../asn1-cms/build/es2015/key_agree_recipient_info.js';
+import '../../asn1-cms/build/es2015/key_trans_recipient_info.js';
+import { id_signedData } from '../../asn1-cms/build/es2015/object_identifiers.js';
+import '../../asn1-cms/build/es2015/originator_info.js';
+import '../../asn1-cms/build/es2015/password_recipient_info.js';
+import '../../asn1-cms/build/es2015/recipient_info.js';
+import '../../asn1-cms/build/es2015/recipient_infos.js';
+import '../../asn1-cms/build/es2015/revocation_info_choice.js';
+import '../../asn1-cms/build/es2015/signed_data.js';
+import '../../asn1-cms/build/es2015/signer_identifier.js';
+import '../../asn1-cms/build/es2015/signer_info.js';
+import '../../asn1-cms/build/es2015/types.js';
+import { ecdsaWithSHA512, ecdsaWithSHA384, ecdsaWithSHA256, ecdsaWithSHA1 } from '../../asn1-ecc/build/es2015/algorithms.js';
+import { ECParameters } from '../../asn1-ecc/build/es2015/ec_parameters.js';
+import '../../asn1-ecc/build/es2015/ec_private_key.js';
+import { ECDSASigValue } from '../../asn1-ecc/build/es2015/ec_signature_value.js';
+import { id_ecPublicKey, id_ecdsaWithSHA512, id_ecdsaWithSHA384, id_ecdsaWithSHA256, id_ecdsaWithSHA224, id_ecdsaWithSHA1, id_secp521r1, id_secp384r1, id_secp256r1 } from '../../asn1-ecc/build/es2015/object_identifiers.js';
+import '../../asn1-ecc/build/es2015/rfc3279.js';
+import '../../asn1-rsa/build/es2015/parameters/rsaes_oaep.js';
+import { RsaSaPssParams } from '../../asn1-rsa/build/es2015/parameters/rsassa_pss.js';
+import '../../asn1-rsa/build/es2015/parameters/rsassa_pkcs1_v1_5.js';
+import '../../asn1-rsa/build/es2015/algorithms.js';
+import { id_RSASSA_PSS, id_rsaEncryption, id_sha512WithRSAEncryption, id_sha384WithRSAEncryption, id_sha256WithRSAEncryption, id_sha224WithRSAEncryption, id_sha1WithRSAEncryption, id_sha512, id_sha384, id_sha256, id_sha224, id_sha1, id_mgf1 } from '../../asn1-rsa/build/es2015/object_identifiers.js';
+import '../../asn1-rsa/build/es2015/other_prime_info.js';
+import '../../asn1-rsa/build/es2015/rsa_private_key.js';
+import { RSAPublicKey } from '../../asn1-rsa/build/es2015/rsa_public_key.js';
+import { __decorate } from '../../../tslib/tslib.es6.js';
+import '../../../tsyringe/dist/esm5/index.js';
+import { id_pkcs9_at_challengePassword, id_pkcs9_at_extensionRequest, ChallengePassword } from '../../asn1-pkcs9/build/es2015/index.js';
+import '../../asn1-csr/build/es2015/attributes.js';
+import { CertificationRequest } from '../../asn1-csr/build/es2015/certification_request.js';
+import '../../asn1-csr/build/es2015/certification_request_info.js';
+import { instance } from '../../../tsyringe/dist/esm5/dependency-container.js';
+import injectable from '../../../tsyringe/dist/esm5/decorators/injectable.js';
+import '../../../tsyringe/dist/esm5/lazy-helpers.js';
+
+/*!
+ * MIT License
+ * 
+ * Copyright (c) Peculiar Ventures. All rights reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+const diAlgorithm = "crypto.algorithm";
+class AlgorithmProvider {
+  getAlgorithms() {
+    return instance.resolveAll(diAlgorithm);
+  }
+  toAsnAlgorithm(alg) {
+    ({
+      ...alg
+    });
+    for (const algorithm of this.getAlgorithms()) {
+      const res = algorithm.toAsnAlgorithm(alg);
+      if (res) {
+        return res;
+      }
+    }
+    if (/^[0-9.]+$/.test(alg.name)) {
+      const res = new AlgorithmIdentifier({
+        algorithm: alg.name
+      });
+      if ("parameters" in alg) {
+        const unknown = alg;
+        res.parameters = unknown.parameters;
+      }
+      return res;
+    }
+    throw new Error("Cannot convert WebCrypto algorithm to ASN.1 algorithm");
+  }
+  toWebAlgorithm(alg) {
+    for (const algorithm of this.getAlgorithms()) {
+      const res = algorithm.toWebAlgorithm(alg);
+      if (res) {
+        return res;
+      }
+    }
+    const unknown = {
+      name: alg.algorithm,
+      parameters: alg.parameters
+    };
+    return unknown;
+  }
+}
+const diAlgorithmProvider = "crypto.algorithmProvider";
+instance.registerSingleton(diAlgorithmProvider, AlgorithmProvider);
+var EcAlgorithm_1;
+const idVersionOne = "1.3.36.3.3.2.8.1.1";
+const idBrainpoolP160r1 = `${idVersionOne}.1`;
+const idBrainpoolP160t1 = `${idVersionOne}.2`;
+const idBrainpoolP192r1 = `${idVersionOne}.3`;
+const idBrainpoolP192t1 = `${idVersionOne}.4`;
+const idBrainpoolP224r1 = `${idVersionOne}.5`;
+const idBrainpoolP224t1 = `${idVersionOne}.6`;
+const idBrainpoolP256r1 = `${idVersionOne}.7`;
+const idBrainpoolP256t1 = `${idVersionOne}.8`;
+const idBrainpoolP320r1 = `${idVersionOne}.9`;
+const idBrainpoolP320t1 = `${idVersionOne}.10`;
+const idBrainpoolP384r1 = `${idVersionOne}.11`;
+const idBrainpoolP384t1 = `${idVersionOne}.12`;
+const idBrainpoolP512r1 = `${idVersionOne}.13`;
+const idBrainpoolP512t1 = `${idVersionOne}.14`;
+const brainpoolP160r1 = "brainpoolP160r1";
+const brainpoolP160t1 = "brainpoolP160t1";
+const brainpoolP192r1 = "brainpoolP192r1";
+const brainpoolP192t1 = "brainpoolP192t1";
+const brainpoolP224r1 = "brainpoolP224r1";
+const brainpoolP224t1 = "brainpoolP224t1";
+const brainpoolP256r1 = "brainpoolP256r1";
+const brainpoolP256t1 = "brainpoolP256t1";
+const brainpoolP320r1 = "brainpoolP320r1";
+const brainpoolP320t1 = "brainpoolP320t1";
+const brainpoolP384r1 = "brainpoolP384r1";
+const brainpoolP384t1 = "brainpoolP384t1";
+const brainpoolP512r1 = "brainpoolP512r1";
+const brainpoolP512t1 = "brainpoolP512t1";
+const ECDSA = "ECDSA";
+let EcAlgorithm = EcAlgorithm_1 = class EcAlgorithm {
+  toAsnAlgorithm(alg) {
+    switch (alg.name.toLowerCase()) {
+      case ECDSA.toLowerCase():
+        if ("hash" in alg) {
+          const hash = typeof alg.hash === "string" ? alg.hash : alg.hash.name;
+          switch (hash.toLowerCase()) {
+            case "sha-1":
+              return ecdsaWithSHA1;
+            case "sha-256":
+              return ecdsaWithSHA256;
+            case "sha-384":
+              return ecdsaWithSHA384;
+            case "sha-512":
+              return ecdsaWithSHA512;
+          }
+        } else if ("namedCurve" in alg) {
+          let parameters = "";
+          switch (alg.namedCurve) {
+            case "P-256":
+              parameters = id_secp256r1;
+              break;
+            case "K-256":
+              parameters = EcAlgorithm_1.SECP256K1;
+              break;
+            case "P-384":
+              parameters = id_secp384r1;
+              break;
+            case "P-521":
+              parameters = id_secp521r1;
+              break;
+            case brainpoolP160r1:
+              parameters = idBrainpoolP160r1;
+              break;
+            case brainpoolP160t1:
+              parameters = idBrainpoolP160t1;
+              break;
+            case brainpoolP192r1:
+              parameters = idBrainpoolP192r1;
+              break;
+            case brainpoolP192t1:
+              parameters = idBrainpoolP192t1;
+              break;
+            case brainpoolP224r1:
+              parameters = idBrainpoolP224r1;
+              break;
+            case brainpoolP224t1:
+              parameters = idBrainpoolP224t1;
+              break;
+            case brainpoolP256r1:
+              parameters = idBrainpoolP256r1;
+              break;
+            case brainpoolP256t1:
+              parameters = idBrainpoolP256t1;
+              break;
+            case brainpoolP320r1:
+              parameters = idBrainpoolP320r1;
+              break;
+            case brainpoolP320t1:
+              parameters = idBrainpoolP320t1;
+              break;
+            case brainpoolP384r1:
+              parameters = idBrainpoolP384r1;
+              break;
+            case brainpoolP384t1:
+              parameters = idBrainpoolP384t1;
+              break;
+            case brainpoolP512r1:
+              parameters = idBrainpoolP512r1;
+              break;
+            case brainpoolP512t1:
+              parameters = idBrainpoolP512t1;
+              break;
+          }
+          if (parameters) {
+            return new AlgorithmIdentifier({
+              algorithm: id_ecPublicKey,
+              parameters: AsnConvert.serialize(new ECParameters({
+                namedCurve: parameters
+              }))
+            });
+          }
+        }
+    }
+    return null;
+  }
+  toWebAlgorithm(alg) {
+    switch (alg.algorithm) {
+      case id_ecdsaWithSHA1:
+        return {
+          name: ECDSA,
+          hash: {
+            name: "SHA-1"
+          }
+        };
+      case id_ecdsaWithSHA256:
+        return {
+          name: ECDSA,
+          hash: {
+            name: "SHA-256"
+          }
+        };
+      case id_ecdsaWithSHA384:
+        return {
+          name: ECDSA,
+          hash: {
+            name: "SHA-384"
+          }
+        };
+      case id_ecdsaWithSHA512:
+        return {
+          name: ECDSA,
+          hash: {
+            name: "SHA-512"
+          }
+        };
+      case id_ecPublicKey:
+        {
+          if (!alg.parameters) {
+            throw new TypeError("Cannot get required parameters from EC algorithm");
+          }
+          const parameters = AsnConvert.parse(alg.parameters, ECParameters);
+          switch (parameters.namedCurve) {
+            case id_secp256r1:
+              return {
+                name: ECDSA,
+                namedCurve: "P-256"
+              };
+            case EcAlgorithm_1.SECP256K1:
+              return {
+                name: ECDSA,
+                namedCurve: "K-256"
+              };
+            case id_secp384r1:
+              return {
+                name: ECDSA,
+                namedCurve: "P-384"
+              };
+            case id_secp521r1:
+              return {
+                name: ECDSA,
+                namedCurve: "P-521"
+              };
+            case idBrainpoolP160r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP160r1
+              };
+            case idBrainpoolP160t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP160t1
+              };
+            case idBrainpoolP192r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP192r1
+              };
+            case idBrainpoolP192t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP192t1
+              };
+            case idBrainpoolP224r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP224r1
+              };
+            case idBrainpoolP224t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP224t1
+              };
+            case idBrainpoolP256r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP256r1
+              };
+            case idBrainpoolP256t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP256t1
+              };
+            case idBrainpoolP320r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP320r1
+              };
+            case idBrainpoolP320t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP320t1
+              };
+            case idBrainpoolP384r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP384r1
+              };
+            case idBrainpoolP384t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP384t1
+              };
+            case idBrainpoolP512r1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP512r1
+              };
+            case idBrainpoolP512t1:
+              return {
+                name: ECDSA,
+                namedCurve: brainpoolP512t1
+              };
+          }
+        }
+    }
+    return null;
+  }
+};
+EcAlgorithm.SECP256K1 = "1.3.132.0.10";
+EcAlgorithm = EcAlgorithm_1 = __decorate([injectable()], EcAlgorithm);
+instance.registerSingleton(diAlgorithm, EcAlgorithm);
+const NAME = Symbol("name");
+const VALUE = Symbol("value");
+class TextObject {
+  constructor(name) {
+    let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";
+    this[NAME] = name;
+    this[VALUE] = value;
+    for (const key in items) {
+      this[key] = items[key];
+    }
+  }
+}
+TextObject.NAME = NAME;
+TextObject.VALUE = VALUE;
+class DefaultAlgorithmSerializer {
+  static toTextObject(alg) {
+    const obj = new TextObject("Algorithm Identifier", {}, OidSerializer.toString(alg.algorithm));
+    if (alg.parameters) {
+      switch (alg.algorithm) {
+        case id_ecPublicKey:
+          {
+            const ecAlg = new EcAlgorithm().toWebAlgorithm(alg);
+            if (ecAlg && "namedCurve" in ecAlg) {
+              obj["Named Curve"] = ecAlg.namedCurve;
+            } else {
+              obj["Parameters"] = alg.parameters;
+            }
+            break;
+          }
+        default:
+          obj["Parameters"] = alg.parameters;
+      }
+    }
+    return obj;
+  }
+}
+class OidSerializer {
+  static toString(oid) {
+    const name = this.items[oid];
+    if (name) {
+      return name;
+    }
+    return oid;
+  }
+}
+OidSerializer.items = {
+  [id_sha1]: "sha1",
+  [id_sha224]: "sha224",
+  [id_sha256]: "sha256",
+  [id_sha384]: "sha384",
+  [id_sha512]: "sha512",
+  [id_rsaEncryption]: "rsaEncryption",
+  [id_sha1WithRSAEncryption]: "sha1WithRSAEncryption",
+  [id_sha224WithRSAEncryption]: "sha224WithRSAEncryption",
+  [id_sha256WithRSAEncryption]: "sha256WithRSAEncryption",
+  [id_sha384WithRSAEncryption]: "sha384WithRSAEncryption",
+  [id_sha512WithRSAEncryption]: "sha512WithRSAEncryption",
+  [id_ecPublicKey]: "ecPublicKey",
+  [id_ecdsaWithSHA1]: "ecdsaWithSHA1",
+  [id_ecdsaWithSHA224]: "ecdsaWithSHA224",
+  [id_ecdsaWithSHA256]: "ecdsaWithSHA256",
+  [id_ecdsaWithSHA384]: "ecdsaWithSHA384",
+  [id_ecdsaWithSHA512]: "ecdsaWithSHA512",
+  [id_kp_serverAuth]: "TLS WWW server authentication",
+  [id_kp_clientAuth]: "TLS WWW client authentication",
+  [id_kp_codeSigning]: "Code Signing",
+  [id_kp_emailProtection]: "E-mail Protection",
+  [id_kp_timeStamping]: "Time Stamping",
+  [id_kp_OCSPSigning]: "OCSP Signing",
+  [id_signedData]: "Signed Data"
+};
+class TextConverter {
+  static serialize(obj) {
+    return this.serializeObj(obj).join("\n");
+  }
+  static pad() {
+    let deep = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    return "".padStart(2 * deep, " ");
+  }
+  static serializeObj(obj) {
+    let deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    const res = [];
+    let pad = this.pad(deep++);
+    let value = "";
+    const objValue = obj[TextObject.VALUE];
+    if (objValue) {
+      value = ` ${objValue}`;
+    }
+    res.push(`${pad}${obj[TextObject.NAME]}:${value}`);
+    pad = this.pad(deep);
+    for (const key in obj) {
+      if (typeof key === "symbol") {
+        continue;
+      }
+      const value = obj[key];
+      const keyValue = key ? `${key}: ` : "";
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        res.push(`${pad}${keyValue}${value}`);
+      } else if (value instanceof Date) {
+        res.push(`${pad}${keyValue}${value.toUTCString()}`);
+      } else if (Array.isArray(value)) {
+        for (const obj of value) {
+          obj[TextObject.NAME] = key;
+          res.push(...this.serializeObj(obj, deep));
+        }
+      } else if (value instanceof TextObject) {
+        value[TextObject.NAME] = key;
+        res.push(...this.serializeObj(value, deep));
+      } else if (buildExports.BufferSourceConverter.isBufferSource(value)) {
+        if (key) {
+          res.push(`${pad}${keyValue}`);
+          res.push(...this.serializeBufferSource(value, deep + 1));
+        } else {
+          res.push(...this.serializeBufferSource(value, deep));
+        }
+      } else if ("toTextObject" in value) {
+        const obj = value.toTextObject();
+        obj[TextObject.NAME] = key;
+        res.push(...this.serializeObj(obj, deep));
+      } else {
+        throw new TypeError("Cannot serialize data in text format. Unsupported type.");
+      }
+    }
+    return res;
+  }
+  static serializeBufferSource(buffer) {
+    let deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    const pad = this.pad(deep);
+    const view = buildExports.BufferSourceConverter.toUint8Array(buffer);
+    const res = [];
+    for (let i = 0; i < view.length;) {
+      const row = [];
+      for (let j = 0; j < 16 && i < view.length; j++) {
+        if (j === 8) {
+          row.push("");
+        }
+        const hex = view[i++].toString(16).padStart(2, "0");
+        row.push(hex);
+      }
+      res.push(`${pad}${row.join(" ")}`);
+    }
+    return res;
+  }
+  static serializeAlgorithm(alg) {
+    return this.algorithmSerializer.toTextObject(alg);
+  }
+}
+TextConverter.oidSerializer = OidSerializer;
+TextConverter.algorithmSerializer = DefaultAlgorithmSerializer;
+class AsnData {
+  constructor() {
+    if (arguments.length === 1) {
+      const asn = arguments.length <= 0 ? undefined : arguments[0];
+      this.rawData = AsnConvert.serialize(asn);
+      this.onInit(asn);
+    } else {
+      const asn = AsnConvert.parse(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1]);
+      this.rawData = buildExports.BufferSourceConverter.toArrayBuffer(arguments.length <= 0 ? undefined : arguments[0]);
+      this.onInit(asn);
+    }
+  }
+  equal(data) {
+    if (data instanceof AsnData) {
+      return buildExports.isEqual(data.rawData, this.rawData);
+    }
+    return false;
+  }
+  toString() {
+    let format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "text";
+    switch (format) {
+      case "asn":
+        return AsnConvert.toString(this.rawData);
+      case "text":
+        return TextConverter.serialize(this.toTextObject());
+      case "hex":
+        return buildExports.Convert.ToHex(this.rawData);
+      case "base64":
+        return buildExports.Convert.ToBase64(this.rawData);
+      case "base64url":
+        return buildExports.Convert.ToBase64Url(this.rawData);
+      default:
+        throw TypeError("Argument 'format' is unsupported value");
+    }
+  }
+  getTextName() {
+    const constructor = this.constructor;
+    return constructor.NAME;
+  }
+  toTextObject() {
+    const obj = this.toTextObjectEmpty();
+    obj[""] = this.rawData;
+    return obj;
+  }
+  toTextObjectEmpty(value) {
+    return new TextObject(this.getTextName(), {}, value);
+  }
+}
+AsnData.NAME = "ASN";
+class Extension extends AsnData {
+  constructor() {
+    let raw;
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      raw = buildExports.BufferSourceConverter.toArrayBuffer(arguments.length <= 0 ? undefined : arguments[0]);
+    } else {
+      raw = AsnConvert.serialize(new Extension$1({
+        extnID: arguments.length <= 0 ? undefined : arguments[0],
+        critical: arguments.length <= 1 ? undefined : arguments[1],
+        extnValue: new OctetString(buildExports.BufferSourceConverter.toArrayBuffer(arguments.length <= 2 ? undefined : arguments[2]))
+      }));
+    }
+    super(raw, Extension$1);
+  }
+  onInit(asn) {
+    this.type = asn.extnID;
+    this.critical = asn.critical;
+    this.value = asn.extnValue.buffer;
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    obj[""] = this.value;
+    return obj;
+  }
+  toTextObjectWithoutValue() {
+    const obj = this.toTextObjectEmpty(this.critical ? "critical" : undefined);
+    if (obj[TextObject.NAME] === Extension.NAME) {
+      obj[TextObject.NAME] = OidSerializer.toString(this.type);
+    }
+    return obj;
+  }
+}
+var _a;
+class CryptoProvider {
+  static isCryptoKeyPair(data) {
+    return data && data.privateKey && data.publicKey;
+  }
+  static isCryptoKey(data) {
+    return data && data.usages && data.type && data.algorithm && data.extractable !== undefined;
+  }
+  constructor() {
+    this.items = new Map();
+    this[_a] = "CryptoProvider";
+    if (typeof self !== "undefined" && typeof crypto !== "undefined") {
+      this.set(CryptoProvider.DEFAULT, crypto);
+    } else if (typeof global !== "undefined" && global.crypto && global.crypto.subtle) {
+      this.set(CryptoProvider.DEFAULT, global.crypto);
+    }
+  }
+  clear() {
+    this.items.clear();
+  }
+  delete(key) {
+    return this.items.delete(key);
+  }
+  forEach(callbackfn, thisArg) {
+    return this.items.forEach(callbackfn, thisArg);
+  }
+  has(key) {
+    return this.items.has(key);
+  }
+  get size() {
+    return this.items.size;
+  }
+  entries() {
+    return this.items.entries();
+  }
+  keys() {
+    return this.items.keys();
+  }
+  values() {
+    return this.items.values();
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  get() {
+    let key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : CryptoProvider.DEFAULT;
+    const crypto = this.items.get(key.toLowerCase());
+    if (!crypto) {
+      throw new Error(`Cannot get Crypto by name '${key}'`);
+    }
+    return crypto;
+  }
+  set(key, value) {
+    if (typeof key === "string") {
+      if (!value) {
+        throw new TypeError("Argument 'value' is required");
+      }
+      this.items.set(key.toLowerCase(), value);
+    } else {
+      this.items.set(CryptoProvider.DEFAULT, key);
+    }
+    return this;
+  }
+}
+_a = Symbol.toStringTag;
+CryptoProvider.DEFAULT = "default";
+const cryptoProvider = new CryptoProvider();
+const OID_REGEX = /^[0-2](?:\.[1-9][0-9]*)+$/;
+function isOID(id) {
+  return new RegExp(OID_REGEX).test(id);
+}
+class NameIdentifier {
+  constructor() {
+    let names = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.items = {};
+    for (const id in names) {
+      this.register(id, names[id]);
+    }
+  }
+  get(idOrName) {
+    return this.items[idOrName] || null;
+  }
+  findId(idOrName) {
+    if (!isOID(idOrName)) {
+      return this.get(idOrName);
+    }
+    return idOrName;
+  }
+  register(id, name) {
+    this.items[id] = name;
+    this.items[name] = id;
+  }
+}
+const names = new NameIdentifier();
+names.register("CN", "2.5.4.3");
+names.register("L", "2.5.4.7");
+names.register("ST", "2.5.4.8");
+names.register("O", "2.5.4.10");
+names.register("OU", "2.5.4.11");
+names.register("C", "2.5.4.6");
+names.register("DC", "0.9.2342.19200300.100.1.25");
+names.register("E", "1.2.840.113549.1.9.1");
+names.register("G", "2.5.4.42");
+names.register("I", "2.5.4.43");
+names.register("SN", "2.5.4.4");
+names.register("T", "2.5.4.12");
+function replaceUnknownCharacter(text, char) {
+  return `\\${buildExports.Convert.ToHex(buildExports.Convert.FromUtf8String(char)).toUpperCase()}`;
+}
+function escape(data) {
+  return data.replace(/([,+"\\<>;])/g, "\\$1").replace(/^([ #])/, "\\$1").replace(/([ ]$)/, "\\$1").replace(/([\r\n\t])/, replaceUnknownCharacter);
+}
+class Name {
+  static isASCII(text) {
+    for (let i = 0; i < text.length; i++) {
+      const code = text.charCodeAt(i);
+      if (code > 0xFF) {
+        return false;
+      }
+    }
+    return true;
+  }
+  static isPrintableString(text) {
+    return /^[A-Za-z0-9 '()+,-./:=?]*$/g.test(text);
+  }
+  constructor(data) {
+    let extraNames = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.extraNames = new NameIdentifier();
+    this.asn = new Name$1();
+    for (const key in extraNames) {
+      if (Object.prototype.hasOwnProperty.call(extraNames, key)) {
+        const value = extraNames[key];
+        this.extraNames.register(key, value);
+      }
+    }
+    if (typeof data === "string") {
+      this.asn = this.fromString(data);
+    } else if (data instanceof Name$1) {
+      this.asn = data;
+    } else if (buildExports.BufferSourceConverter.isBufferSource(data)) {
+      this.asn = AsnConvert.parse(data, Name$1);
+    } else {
+      this.asn = this.fromJSON(data);
+    }
+  }
+  getField(idOrName) {
+    const id = this.extraNames.findId(idOrName) || names.findId(idOrName);
+    const res = [];
+    for (const name of this.asn) {
+      for (const rdn of name) {
+        if (rdn.type === id) {
+          res.push(rdn.value.toString());
+        }
+      }
+    }
+    return res;
+  }
+  getName(idOrName) {
+    return this.extraNames.get(idOrName) || names.get(idOrName);
+  }
+  toString() {
+    return this.asn.map(rdn => rdn.map(o => {
+      const type = this.getName(o.type) || o.type;
+      const value = o.value.anyValue ? `#${buildExports.Convert.ToHex(o.value.anyValue)}` : escape(o.value.toString());
+      return `${type}=${value}`;
+    }).join("+")).join(", ");
+  }
+  toJSON() {
+    var _a;
+    const json = [];
+    for (const rdn of this.asn) {
+      const jsonItem = {};
+      for (const attr of rdn) {
+        const type = this.getName(attr.type) || attr.type;
+        (_a = jsonItem[type]) !== null && _a !== void 0 ? _a : jsonItem[type] = [];
+        jsonItem[type].push(attr.value.anyValue ? `#${buildExports.Convert.ToHex(attr.value.anyValue)}` : attr.value.toString());
+      }
+      json.push(jsonItem);
+    }
+    return json;
+  }
+  fromString(data) {
+    const asn = new Name$1();
+    const regex = /(\d\.[\d.]*\d|[A-Za-z]+)=((?:"")|(?:".*?[^\\]")|(?:[^,+].*?(?:[^\\][,+]))|(?:))([,+])?/g;
+    let matches = null;
+    let level = ",";
+    while (matches = regex.exec(`${data},`)) {
+      let [, type, value] = matches;
+      const lastChar = value[value.length - 1];
+      if (lastChar === "," || lastChar === "+") {
+        value = value.slice(0, value.length - 1);
+        matches[3] = lastChar;
+      }
+      const next = matches[3];
+      type = this.getTypeOid(type);
+      const attr = this.createAttribute(type, value);
+      if (level === "+") {
+        asn[asn.length - 1].push(attr);
+      } else {
+        asn.push(new RelativeDistinguishedName([attr]));
+      }
+      level = next;
+    }
+    return asn;
+  }
+  fromJSON(data) {
+    const asn = new Name$1();
+    for (const item of data) {
+      const asnRdn = new RelativeDistinguishedName();
+      for (const type in item) {
+        const typeId = this.getTypeOid(type);
+        const values = item[type];
+        for (const value of values) {
+          const asnAttr = this.createAttribute(typeId, value);
+          asnRdn.push(asnAttr);
+        }
+      }
+      asn.push(asnRdn);
+    }
+    return asn;
+  }
+  getTypeOid(type) {
+    if (!/[\d.]+/.test(type)) {
+      type = this.getName(type) || "";
+    }
+    if (!type) {
+      throw new Error(`Cannot get OID for name type '${type}'`);
+    }
+    return type;
+  }
+  createAttribute(type, value) {
+    const attr = new AttributeTypeAndValue({
+      type
+    });
+    if (typeof value === "object") {
+      for (const key in value) {
+        switch (key) {
+          case "ia5String":
+            attr.value.ia5String = value[key];
+            break;
+          case "utf8String":
+            attr.value.utf8String = value[key];
+            break;
+          case "universalString":
+            attr.value.universalString = value[key];
+            break;
+          case "bmpString":
+            attr.value.bmpString = value[key];
+            break;
+          case "printableString":
+            attr.value.printableString = value[key];
+            break;
+        }
+      }
+    } else if (value[0] === "#") {
+      attr.value.anyValue = buildExports.Convert.FromHex(value.slice(1));
+    } else {
+      const processedValue = this.processStringValue(value);
+      if (type === this.getName("E") || type === this.getName("DC")) {
+        attr.value.ia5String = processedValue;
+      } else {
+        if (Name.isPrintableString(processedValue)) {
+          attr.value.printableString = processedValue;
+        } else {
+          attr.value.utf8String = processedValue;
+        }
+      }
+    }
+    return attr;
+  }
+  processStringValue(value) {
+    const quotedMatches = /"(.*?[^\\])?"/.exec(value);
+    if (quotedMatches) {
+      value = quotedMatches[1];
+    }
+    return value.replace(/\\0a/ig, "\n").replace(/\\0d/ig, "\r").replace(/\\0g/ig, "\t").replace(/\\(.)/g, "$1");
+  }
+  toArrayBuffer() {
+    return AsnConvert.serialize(this.asn);
+  }
+  async getThumbprint() {
+    var _a;
+    let crypto;
+    let algorithm = "SHA-1";
+    if (arguments.length >= 1 && !((_a = arguments.length <= 0 ? undefined : arguments[0]) === null || _a === void 0 ? void 0 : _a.subtle)) {
+      algorithm = (arguments.length <= 0 ? undefined : arguments[0]) || algorithm;
+      crypto = (arguments.length <= 1 ? undefined : arguments[1]) || cryptoProvider.get();
+    } else {
+      crypto = (arguments.length <= 0 ? undefined : arguments[0]) || cryptoProvider.get();
+    }
+    return await crypto.subtle.digest(algorithm, this.toArrayBuffer());
+  }
+}
+const ERR_GN_CONSTRUCTOR = "Cannot initialize GeneralName from ASN.1 data.";
+const ERR_GN_STRING_FORMAT = `${ERR_GN_CONSTRUCTOR} Unsupported string format in use.`;
+const ERR_GUID = `${ERR_GN_CONSTRUCTOR} Value doesn't match to GUID regular expression.`;
+const GUID_REGEX = /^([0-9a-f]{8})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{12})$/i;
+const id_GUID = "1.3.6.1.4.1.311.25.1";
+const id_UPN = "1.3.6.1.4.1.311.20.2.3";
+const DNS = "dns";
+const DN = "dn";
+const EMAIL = "email";
+const IP = "ip";
+const URL = "url";
+const GUID = "guid";
+const UPN = "upn";
+const REGISTERED_ID = "id";
+class GeneralName extends AsnData {
+  constructor() {
+    let name;
+    if (arguments.length === 2) {
+      switch (arguments.length <= 0 ? undefined : arguments[0]) {
+        case DN:
+          {
+            const derName = new Name(arguments.length <= 1 ? undefined : arguments[1]).toArrayBuffer();
+            const asnName = AsnConvert.parse(derName, Name$1);
+            name = new GeneralName$1({
+              directoryName: asnName
+            });
+            break;
+          }
+        case DNS:
+          name = new GeneralName$1({
+            dNSName: arguments.length <= 1 ? undefined : arguments[1]
+          });
+          break;
+        case EMAIL:
+          name = new GeneralName$1({
+            rfc822Name: arguments.length <= 1 ? undefined : arguments[1]
+          });
+          break;
+        case GUID:
+          {
+            const matches = new RegExp(GUID_REGEX, "i").exec(arguments.length <= 1 ? undefined : arguments[1]);
+            if (!matches) {
+              throw new Error("Cannot parse GUID value. Value doesn't match to regular expression");
+            }
+            const hex = matches.slice(1).map((o, i) => {
+              if (i < 3) {
+                return buildExports.Convert.ToHex(new Uint8Array(buildExports.Convert.FromHex(o)).reverse());
+              }
+              return o;
+            }).join("");
+            name = new GeneralName$1({
+              otherName: new OtherName({
+                typeId: id_GUID,
+                value: AsnConvert.serialize(new OctetString(buildExports.Convert.FromHex(hex)))
+              })
+            });
+            break;
+          }
+        case IP:
+          name = new GeneralName$1({
+            iPAddress: arguments.length <= 1 ? undefined : arguments[1]
+          });
+          break;
+        case REGISTERED_ID:
+          name = new GeneralName$1({
+            registeredID: arguments.length <= 1 ? undefined : arguments[1]
+          });
+          break;
+        case UPN:
+          {
+            name = new GeneralName$1({
+              otherName: new OtherName({
+                typeId: id_UPN,
+                value: AsnConvert.serialize(AsnUtf8StringConverter.toASN(arguments.length <= 1 ? undefined : arguments[1]))
+              })
+            });
+            break;
+          }
+        case URL:
+          name = new GeneralName$1({
+            uniformResourceIdentifier: arguments.length <= 1 ? undefined : arguments[1]
+          });
+          break;
+        default:
+          throw new Error("Cannot create GeneralName. Unsupported type of the name");
+      }
+    } else if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      name = AsnConvert.parse(arguments.length <= 0 ? undefined : arguments[0], GeneralName$1);
+    } else {
+      name = arguments.length <= 0 ? undefined : arguments[0];
+    }
+    super(name);
+  }
+  onInit(asn) {
+    if (asn.dNSName != undefined) {
+      this.type = DNS;
+      this.value = asn.dNSName;
+    } else if (asn.rfc822Name != undefined) {
+      this.type = EMAIL;
+      this.value = asn.rfc822Name;
+    } else if (asn.iPAddress != undefined) {
+      this.type = IP;
+      this.value = asn.iPAddress;
+    } else if (asn.uniformResourceIdentifier != undefined) {
+      this.type = URL;
+      this.value = asn.uniformResourceIdentifier;
+    } else if (asn.registeredID != undefined) {
+      this.type = REGISTERED_ID;
+      this.value = asn.registeredID;
+    } else if (asn.directoryName != undefined) {
+      this.type = DN;
+      this.value = new Name(asn.directoryName).toString();
+    } else if (asn.otherName != undefined) {
+      if (asn.otherName.typeId === id_GUID) {
+        this.type = GUID;
+        const guid = AsnConvert.parse(asn.otherName.value, OctetString);
+        const matches = new RegExp(GUID_REGEX, "i").exec(buildExports.Convert.ToHex(guid));
+        if (!matches) {
+          throw new Error(ERR_GUID);
+        }
+        this.value = matches.slice(1).map((o, i) => {
+          if (i < 3) {
+            return buildExports.Convert.ToHex(new Uint8Array(buildExports.Convert.FromHex(o)).reverse());
+          }
+          return o;
+        }).join("-");
+      } else if (asn.otherName.typeId === id_UPN) {
+        this.type = UPN;
+        this.value = AsnConvert.parse(asn.otherName.value, DirectoryString).toString();
+      } else {
+        throw new Error(ERR_GN_STRING_FORMAT);
+      }
+    } else {
+      throw new Error(ERR_GN_STRING_FORMAT);
+    }
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      value: this.value
+    };
+  }
+  toTextObject() {
+    let type;
+    switch (this.type) {
+      case DN:
+      case DNS:
+      case GUID:
+      case IP:
+      case REGISTERED_ID:
+      case UPN:
+      case URL:
+        type = this.type.toUpperCase();
+        break;
+      case EMAIL:
+        type = "Email";
+        break;
+      default:
+        throw new Error("Unsupported GeneralName type");
+    }
+    let value = this.value;
+    if (this.type === REGISTERED_ID) {
+      value = OidSerializer.toString(value);
+    }
+    return new TextObject(type, undefined, value);
+  }
+}
+class GeneralNames extends AsnData {
+  constructor(params) {
+    let names;
+    if (params instanceof GeneralNames$1) {
+      names = params;
+    } else if (Array.isArray(params)) {
+      const items = [];
+      for (const name of params) {
+        if (name instanceof GeneralName$1) {
+          items.push(name);
+        } else {
+          const asnName = AsnConvert.parse(new GeneralName(name.type, name.value).rawData, GeneralName$1);
+          items.push(asnName);
+        }
+      }
+      names = new GeneralNames$1(items);
+    } else if (buildExports.BufferSourceConverter.isBufferSource(params)) {
+      names = AsnConvert.parse(params, GeneralNames$1);
+    } else {
+      throw new Error("Cannot initialize GeneralNames. Incorrect incoming arguments");
+    }
+    super(names);
+  }
+  onInit(asn) {
+    const items = [];
+    for (const asnName of asn) {
+      let name = null;
+      try {
+        name = new GeneralName(asnName);
+      } catch {
+        continue;
+      }
+      items.push(name);
+    }
+    this.items = items;
+  }
+  toJSON() {
+    return this.items.map(o => o.toJSON());
+  }
+  toTextObject() {
+    const res = super.toTextObjectEmpty();
+    for (const name of this.items) {
+      const nameObj = name.toTextObject();
+      let field = res[nameObj[TextObject.NAME]];
+      if (!Array.isArray(field)) {
+        field = [];
+        res[nameObj[TextObject.NAME]] = field;
+      }
+      field.push(nameObj);
+    }
+    return res;
+  }
+}
+GeneralNames.NAME = "GeneralNames";
+const rPaddingTag = "-{5}";
+const rEolChars = "\\n";
+const rNameTag = `[^${rEolChars}]+`;
+const rBeginTag = `${rPaddingTag}BEGIN (${rNameTag}(?=${rPaddingTag}))${rPaddingTag}`;
+const rEndTag = `${rPaddingTag}END \\1${rPaddingTag}`;
+const rEolGroup = "\\n";
+const rHeaderKey = `[^:${rEolChars}]+`;
+const rHeaderValue = `(?:[^${rEolChars}]+${rEolGroup}(?: +[^${rEolChars}]+${rEolGroup})*)`;
+const rBase64Chars = "[a-zA-Z0-9=+/]+";
+const rBase64 = `(?:${rBase64Chars}${rEolGroup})+`;
+const rPem = `${rBeginTag}${rEolGroup}(?:((?:${rHeaderKey}: ${rHeaderValue})+))?${rEolGroup}?(${rBase64})${rEndTag}`;
+class PemConverter {
+  static isPem(data) {
+    return typeof data === "string" && new RegExp(rPem, "g").test(data);
+  }
+  static decodeWithHeaders(pem) {
+    pem = pem.replace(/\r/g, "");
+    const pattern = new RegExp(rPem, "g");
+    const res = [];
+    let matches = null;
+    while (matches = pattern.exec(pem)) {
+      const base64 = matches[3].replace(new RegExp(`[${rEolChars}]+`, "g"), "");
+      const pemStruct = {
+        type: matches[1],
+        headers: [],
+        rawData: buildExports.Convert.FromBase64(base64)
+      };
+      const headersString = matches[2];
+      if (headersString) {
+        const headers = headersString.split(new RegExp(rEolGroup, "g"));
+        let lastHeader = null;
+        for (const header of headers) {
+          const [key, value] = header.split(/:(.*)/);
+          if (value === undefined) {
+            if (!lastHeader) {
+              throw new Error("Cannot parse PEM string. Incorrect header value");
+            }
+            lastHeader.value += key.trim();
+          } else {
+            if (lastHeader) {
+              pemStruct.headers.push(lastHeader);
+            }
+            lastHeader = {
+              key,
+              value: value.trim()
+            };
+          }
+        }
+        if (lastHeader) {
+          pemStruct.headers.push(lastHeader);
+        }
+      }
+      res.push(pemStruct);
+    }
+    return res;
+  }
+  static decode(pem) {
+    const blocks = this.decodeWithHeaders(pem);
+    return blocks.map(o => o.rawData);
+  }
+  static decodeFirst(pem) {
+    const items = this.decode(pem);
+    if (!items.length) {
+      throw new RangeError("PEM string doesn't contain any objects");
+    }
+    return items[0];
+  }
+  static encode(rawData, tag) {
+    if (Array.isArray(rawData)) {
+      const raws = new Array();
+      if (tag) {
+        rawData.forEach(element => {
+          if (!buildExports.BufferSourceConverter.isBufferSource(element)) {
+            throw new TypeError("Cannot encode array of BufferSource in PEM format. Not all items of the array are BufferSource");
+          }
+          raws.push(this.encodeStruct({
+            type: tag,
+            rawData: buildExports.BufferSourceConverter.toArrayBuffer(element)
+          }));
+        });
+      } else {
+        rawData.forEach(element => {
+          if (!("type" in element)) {
+            throw new TypeError("Cannot encode array of PemStruct in PEM format. Not all items of the array are PemStrut");
+          }
+          raws.push(this.encodeStruct(element));
+        });
+      }
+      return raws.join("\n");
+    } else {
+      if (!tag) {
+        throw new Error("Required argument 'tag' is missed");
+      }
+      return this.encodeStruct({
+        type: tag,
+        rawData: buildExports.BufferSourceConverter.toArrayBuffer(rawData)
+      });
+    }
+  }
+  static encodeStruct(pem) {
+    var _a;
+    const upperCaseType = pem.type.toLocaleUpperCase();
+    const res = [];
+    res.push(`-----BEGIN ${upperCaseType}-----`);
+    if ((_a = pem.headers) === null || _a === void 0 ? void 0 : _a.length) {
+      for (const header of pem.headers) {
+        res.push(`${header.key}: ${header.value}`);
+      }
+      res.push("");
+    }
+    const base64 = buildExports.Convert.ToBase64(pem.rawData);
+    let sliced;
+    let offset = 0;
+    const rows = Array();
+    while (offset < base64.length) {
+      if (base64.length - offset < 64) {
+        sliced = base64.substring(offset);
+      } else {
+        sliced = base64.substring(offset, offset + 64);
+        offset += 64;
+      }
+      if (sliced.length !== 0) {
+        rows.push(sliced);
+        if (sliced.length < 64) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    res.push(...rows);
+    res.push(`-----END ${upperCaseType}-----`);
+    return res.join("\n");
+  }
+}
+PemConverter.CertificateTag = "CERTIFICATE";
+PemConverter.CrlTag = "CRL";
+PemConverter.CertificateRequestTag = "CERTIFICATE REQUEST";
+PemConverter.PublicKeyTag = "PUBLIC KEY";
+PemConverter.PrivateKeyTag = "PRIVATE KEY";
+class PemData extends AsnData {
+  static isAsnEncoded(data) {
+    return buildExports.BufferSourceConverter.isBufferSource(data) || typeof data === "string";
+  }
+  static toArrayBuffer(raw) {
+    if (typeof raw === "string") {
+      if (PemConverter.isPem(raw)) {
+        return PemConverter.decode(raw)[0];
+      } else if (buildExports.Convert.isHex(raw)) {
+        return buildExports.Convert.FromHex(raw);
+      } else if (buildExports.Convert.isBase64(raw)) {
+        return buildExports.Convert.FromBase64(raw);
+      } else if (buildExports.Convert.isBase64Url(raw)) {
+        return buildExports.Convert.FromBase64Url(raw);
+      } else {
+        throw new TypeError("Unsupported format of 'raw' argument. Must be one of DER, PEM, HEX, Base64, or Base4Url");
+      }
+    } else {
+      const stringRaw = buildExports.Convert.ToBinary(raw);
+      if (PemConverter.isPem(stringRaw)) {
+        return PemConverter.decode(stringRaw)[0];
+      } else if (buildExports.Convert.isHex(stringRaw)) {
+        return buildExports.Convert.FromHex(stringRaw);
+      } else if (buildExports.Convert.isBase64(stringRaw)) {
+        return buildExports.Convert.FromBase64(stringRaw);
+      } else if (buildExports.Convert.isBase64Url(stringRaw)) {
+        return buildExports.Convert.FromBase64Url(stringRaw);
+      }
+      return buildExports.BufferSourceConverter.toArrayBuffer(raw);
+    }
+  }
+  constructor() {
+    if (PemData.isAsnEncoded(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(PemData.toArrayBuffer(arguments.length <= 0 ? undefined : arguments[0]), arguments.length <= 1 ? undefined : arguments[1]);
+    } else {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+    }
+  }
+  toString() {
+    let format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "pem";
+    switch (format) {
+      case "pem":
+        return PemConverter.encode(this.rawData, this.tag);
+      default:
+        return super.toString(format);
+    }
+  }
+}
+class PublicKey extends PemData {
+  static async create(data) {
+    let crypto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : cryptoProvider.get();
+    if (data instanceof PublicKey) {
+      return data;
+    } else if (CryptoProvider.isCryptoKey(data)) {
+      if (data.type !== "public") {
+        throw new TypeError("Public key is required");
+      }
+      const spki = await crypto.subtle.exportKey("spki", data);
+      return new PublicKey(spki);
+    } else if (data.publicKey) {
+      return data.publicKey;
+    } else if (buildExports.BufferSourceConverter.isBufferSource(data)) {
+      return new PublicKey(data);
+    } else {
+      throw new TypeError("Unsupported PublicKeyType");
+    }
+  }
+  constructor(param) {
+    if (PemData.isAsnEncoded(param)) {
+      super(param, SubjectPublicKeyInfo);
+    } else {
+      super(param);
+    }
+    this.tag = PemConverter.PublicKeyTag;
+  }
+  async export() {
+    let crypto;
+    let keyUsages = ["verify"];
+    let algorithm = {
+      hash: "SHA-256",
+      ...this.algorithm
+    };
+    if (arguments.length > 1) {
+      algorithm = (arguments.length <= 0 ? undefined : arguments[0]) || algorithm;
+      keyUsages = (arguments.length <= 1 ? undefined : arguments[1]) || keyUsages;
+      crypto = (arguments.length <= 2 ? undefined : arguments[2]) || cryptoProvider.get();
+    } else {
+      crypto = (arguments.length <= 0 ? undefined : arguments[0]) || cryptoProvider.get();
+    }
+    let raw = this.rawData;
+    const asnSpki = AsnConvert.parse(this.rawData, SubjectPublicKeyInfo);
+    if (asnSpki.algorithm.algorithm === id_RSASSA_PSS) {
+      raw = convertSpkiToRsaPkcs1(asnSpki, raw);
+    }
+    return crypto.subtle.importKey("spki", raw, algorithm, true, keyUsages);
+  }
+  onInit(asn) {
+    const algProv = instance.resolve(diAlgorithmProvider);
+    const algorithm = this.algorithm = algProv.toWebAlgorithm(asn.algorithm);
+    switch (asn.algorithm.algorithm) {
+      case id_rsaEncryption:
+        {
+          const rsaPublicKey = AsnConvert.parse(asn.subjectPublicKey, RSAPublicKey);
+          const modulus = buildExports.BufferSourceConverter.toUint8Array(rsaPublicKey.modulus);
+          algorithm.publicExponent = buildExports.BufferSourceConverter.toUint8Array(rsaPublicKey.publicExponent);
+          algorithm.modulusLength = (!modulus[0] ? modulus.slice(1) : modulus).byteLength << 3;
+          break;
+        }
+    }
+  }
+  async getThumbprint() {
+    var _a;
+    let crypto;
+    let algorithm = "SHA-1";
+    if (arguments.length >= 1 && !((_a = arguments.length <= 0 ? undefined : arguments[0]) === null || _a === void 0 ? void 0 : _a.subtle)) {
+      algorithm = (arguments.length <= 0 ? undefined : arguments[0]) || algorithm;
+      crypto = (arguments.length <= 1 ? undefined : arguments[1]) || cryptoProvider.get();
+    } else {
+      crypto = (arguments.length <= 0 ? undefined : arguments[0]) || cryptoProvider.get();
+    }
+    return await crypto.subtle.digest(algorithm, this.rawData);
+  }
+  async getKeyIdentifier() {
+    let crypto;
+    let algorithm = "SHA-1";
+    if (arguments.length === 1) {
+      if (typeof (arguments.length <= 0 ? undefined : arguments[0]) === "string") {
+        algorithm = arguments.length <= 0 ? undefined : arguments[0];
+        crypto = cryptoProvider.get();
+      } else {
+        crypto = arguments.length <= 0 ? undefined : arguments[0];
+      }
+    } else if (arguments.length === 2) {
+      algorithm = arguments.length <= 0 ? undefined : arguments[0];
+      crypto = arguments.length <= 1 ? undefined : arguments[1];
+    } else {
+      crypto = cryptoProvider.get();
+    }
+    const asn = AsnConvert.parse(this.rawData, SubjectPublicKeyInfo);
+    return await crypto.subtle.digest(algorithm, asn.subjectPublicKey);
+  }
+  toTextObject() {
+    const obj = this.toTextObjectEmpty();
+    const asn = AsnConvert.parse(this.rawData, SubjectPublicKeyInfo);
+    obj["Algorithm"] = TextConverter.serializeAlgorithm(asn.algorithm);
+    switch (asn.algorithm.algorithm) {
+      case id_ecPublicKey:
+        obj["EC Point"] = asn.subjectPublicKey;
+        break;
+      case id_rsaEncryption:
+      default:
+        obj["Raw Data"] = asn.subjectPublicKey;
+    }
+    return obj;
+  }
+}
+function convertSpkiToRsaPkcs1(asnSpki, raw) {
+  asnSpki.algorithm = new AlgorithmIdentifier({
+    algorithm: id_rsaEncryption,
+    parameters: null
+  });
+  raw = AsnConvert.serialize(asnSpki);
+  return raw;
+}
+class AuthorityKeyIdentifierExtension extends Extension {
+  static async create(param) {
+    let critical = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let crypto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : cryptoProvider.get();
+    if ("name" in param && "serialNumber" in param) {
+      return new AuthorityKeyIdentifierExtension(param, critical);
+    }
+    const key = await PublicKey.create(param, crypto);
+    const id = await key.getKeyIdentifier(crypto);
+    return new AuthorityKeyIdentifierExtension(buildExports.Convert.ToHex(id), critical);
+  }
+  constructor() {
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+    } else if (typeof (arguments.length <= 0 ? undefined : arguments[0]) === "string") {
+      const value = new AuthorityKeyIdentifier({
+        keyIdentifier: new KeyIdentifier(buildExports.Convert.FromHex(arguments.length <= 0 ? undefined : arguments[0]))
+      });
+      super(id_ce_authorityKeyIdentifier, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+    } else {
+      const certId = arguments.length <= 0 ? undefined : arguments[0];
+      const certIdName = certId.name instanceof GeneralNames ? AsnConvert.parse(certId.name.rawData, GeneralNames$1) : certId.name;
+      const value = new AuthorityKeyIdentifier({
+        authorityCertIssuer: certIdName,
+        authorityCertSerialNumber: buildExports.Convert.FromHex(certId.serialNumber)
+      });
+      super(id_ce_authorityKeyIdentifier, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+    }
+  }
+  onInit(asn) {
+    super.onInit(asn);
+    const aki = AsnConvert.parse(asn.extnValue, AuthorityKeyIdentifier);
+    if (aki.keyIdentifier) {
+      this.keyId = buildExports.Convert.ToHex(aki.keyIdentifier);
+    }
+    if (aki.authorityCertIssuer || aki.authorityCertSerialNumber) {
+      this.certId = {
+        name: aki.authorityCertIssuer || [],
+        serialNumber: aki.authorityCertSerialNumber ? buildExports.Convert.ToHex(aki.authorityCertSerialNumber) : ""
+      };
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    const asn = AsnConvert.parse(this.value, AuthorityKeyIdentifier);
+    if (asn.authorityCertIssuer) {
+      obj["Authority Issuer"] = new GeneralNames(asn.authorityCertIssuer).toTextObject();
+    }
+    if (asn.authorityCertSerialNumber) {
+      obj["Authority Serial Number"] = asn.authorityCertSerialNumber;
+    }
+    if (asn.keyIdentifier) {
+      obj[""] = asn.keyIdentifier;
+    }
+    return obj;
+  }
+}
+AuthorityKeyIdentifierExtension.NAME = "Authority Key Identifier";
+class BasicConstraintsExtension extends Extension {
+  constructor() {
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+      const value = AsnConvert.parse(this.value, BasicConstraints);
+      this.ca = value.cA;
+      this.pathLength = value.pathLenConstraint;
+    } else {
+      const value = new BasicConstraints({
+        cA: arguments.length <= 0 ? undefined : arguments[0],
+        pathLenConstraint: arguments.length <= 1 ? undefined : arguments[1]
+      });
+      super(id_ce_basicConstraints, arguments.length <= 2 ? undefined : arguments[2], AsnConvert.serialize(value));
+      this.ca = arguments.length <= 0 ? undefined : arguments[0];
+      this.pathLength = arguments.length <= 1 ? undefined : arguments[1];
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    if (this.ca) {
+      obj["CA"] = this.ca;
+    }
+    if (this.pathLength !== undefined) {
+      obj["Path Length"] = this.pathLength;
+    }
+    return obj;
+  }
+}
+BasicConstraintsExtension.NAME = "Basic Constraints";
+var ExtendedKeyUsage;
+(function (ExtendedKeyUsage) {
+  ExtendedKeyUsage["serverAuth"] = "1.3.6.1.5.5.7.3.1";
+  ExtendedKeyUsage["clientAuth"] = "1.3.6.1.5.5.7.3.2";
+  ExtendedKeyUsage["codeSigning"] = "1.3.6.1.5.5.7.3.3";
+  ExtendedKeyUsage["emailProtection"] = "1.3.6.1.5.5.7.3.4";
+  ExtendedKeyUsage["timeStamping"] = "1.3.6.1.5.5.7.3.8";
+  ExtendedKeyUsage["ocspSigning"] = "1.3.6.1.5.5.7.3.9";
+})(ExtendedKeyUsage || (ExtendedKeyUsage = {}));
+class ExtendedKeyUsageExtension extends Extension {
+  constructor() {
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+      const value = AsnConvert.parse(this.value, ExtendedKeyUsage$1);
+      this.usages = value.map(o => o);
+    } else {
+      const value = new ExtendedKeyUsage$1(arguments.length <= 0 ? undefined : arguments[0]);
+      super(id_ce_extKeyUsage, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+      this.usages = arguments.length <= 0 ? undefined : arguments[0];
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    obj[""] = this.usages.map(o => OidSerializer.toString(o)).join(", ");
+    return obj;
+  }
+}
+ExtendedKeyUsageExtension.NAME = "Extended Key Usages";
+var KeyUsageFlags;
+(function (KeyUsageFlags) {
+  KeyUsageFlags[KeyUsageFlags["digitalSignature"] = 1] = "digitalSignature";
+  KeyUsageFlags[KeyUsageFlags["nonRepudiation"] = 2] = "nonRepudiation";
+  KeyUsageFlags[KeyUsageFlags["keyEncipherment"] = 4] = "keyEncipherment";
+  KeyUsageFlags[KeyUsageFlags["dataEncipherment"] = 8] = "dataEncipherment";
+  KeyUsageFlags[KeyUsageFlags["keyAgreement"] = 16] = "keyAgreement";
+  KeyUsageFlags[KeyUsageFlags["keyCertSign"] = 32] = "keyCertSign";
+  KeyUsageFlags[KeyUsageFlags["cRLSign"] = 64] = "cRLSign";
+  KeyUsageFlags[KeyUsageFlags["encipherOnly"] = 128] = "encipherOnly";
+  KeyUsageFlags[KeyUsageFlags["decipherOnly"] = 256] = "decipherOnly";
+})(KeyUsageFlags || (KeyUsageFlags = {}));
+class KeyUsagesExtension extends Extension {
+  constructor() {
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+      const value = AsnConvert.parse(this.value, KeyUsage);
+      this.usages = value.toNumber();
+    } else {
+      const value = new KeyUsage(arguments.length <= 0 ? undefined : arguments[0]);
+      super(id_ce_keyUsage, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+      this.usages = arguments.length <= 0 ? undefined : arguments[0];
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    const asn = AsnConvert.parse(this.value, KeyUsage);
+    obj[""] = asn.toJSON().join(", ");
+    return obj;
+  }
+}
+KeyUsagesExtension.NAME = "Key Usages";
+class SubjectKeyIdentifierExtension extends Extension {
+  static async create(publicKey) {
+    let critical = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let crypto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : cryptoProvider.get();
+    const key = await PublicKey.create(publicKey, crypto);
+    const id = await key.getKeyIdentifier(crypto);
+    return new SubjectKeyIdentifierExtension(buildExports.Convert.ToHex(id), critical);
+  }
+  constructor() {
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+      const value = AsnConvert.parse(this.value, SubjectKeyIdentifier);
+      this.keyId = buildExports.Convert.ToHex(value);
+    } else {
+      const identifier = typeof (arguments.length <= 0 ? undefined : arguments[0]) === "string" ? buildExports.Convert.FromHex(arguments.length <= 0 ? undefined : arguments[0]) : arguments.length <= 0 ? undefined : arguments[0];
+      const value = new SubjectKeyIdentifier(identifier);
+      super(id_ce_subjectKeyIdentifier, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+      this.keyId = buildExports.Convert.ToHex(identifier);
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    const asn = AsnConvert.parse(this.value, SubjectKeyIdentifier);
+    obj[""] = asn;
+    return obj;
+  }
+}
+SubjectKeyIdentifierExtension.NAME = "Subject Key Identifier";
+class SubjectAlternativeNameExtension extends Extension {
+  constructor() {
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+    } else {
+      super(id_ce_subjectAltName, arguments.length <= 1 ? undefined : arguments[1], new GeneralNames((arguments.length <= 0 ? undefined : arguments[0]) || []).rawData);
+    }
+  }
+  onInit(asn) {
+    super.onInit(asn);
+    const value = AsnConvert.parse(asn.extnValue, SubjectAlternativeName);
+    this.names = new GeneralNames(value);
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    const namesObj = this.names.toTextObject();
+    for (const key in namesObj) {
+      obj[key] = namesObj[key];
+    }
+    return obj;
+  }
+}
+SubjectAlternativeNameExtension.NAME = "Subject Alternative Name";
+class ExtensionFactory {
+  static register(id, type) {
+    this.items.set(id, type);
+  }
+  static create(data) {
+    const extension = new Extension(data);
+    const Type = this.items.get(extension.type);
+    if (Type) {
+      return new Type(data);
+    }
+    return extension;
+  }
+}
+ExtensionFactory.items = new Map();
+class CertificatePolicyExtension extends Extension {
+  constructor() {
+    var _a;
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+      const asnPolicies = AsnConvert.parse(this.value, CertificatePolicies);
+      this.policies = asnPolicies.map(o => o.policyIdentifier);
+    } else {
+      const policies = arguments.length <= 0 ? undefined : arguments[0];
+      const critical = (_a = arguments.length <= 1 ? undefined : arguments[1]) !== null && _a !== void 0 ? _a : false;
+      const value = new CertificatePolicies(policies.map(o => new PolicyInformation({
+        policyIdentifier: o
+      })));
+      super(id_ce_certificatePolicies, critical, AsnConvert.serialize(value));
+      this.policies = policies;
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    obj["Policy"] = this.policies.map(o => new TextObject("", {}, OidSerializer.toString(o)));
+    return obj;
+  }
+}
+CertificatePolicyExtension.NAME = "Certificate Policies";
+ExtensionFactory.register(id_ce_certificatePolicies, CertificatePolicyExtension);
+class CRLDistributionPointsExtension extends Extension {
+  constructor() {
+    var _a;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (buildExports.BufferSourceConverter.isBufferSource(args[0])) {
+      super(args[0]);
+    } else if (Array.isArray(args[0]) && typeof args[0][0] === "string") {
+      const urls = args[0];
+      const dps = urls.map(url => {
+        return new DistributionPoint({
+          distributionPoint: new DistributionPointName({
+            fullName: [new GeneralName$1({
+              uniformResourceIdentifier: url
+            })]
+          })
+        });
+      });
+      const value = new CRLDistributionPoints(dps);
+      super(id_ce_cRLDistributionPoints, args[1], AsnConvert.serialize(value));
+    } else {
+      const value = new CRLDistributionPoints(args[0]);
+      super(id_ce_cRLDistributionPoints, args[1], AsnConvert.serialize(value));
+    }
+    (_a = this.distributionPoints) !== null && _a !== void 0 ? _a : this.distributionPoints = [];
+  }
+  onInit(asn) {
+    super.onInit(asn);
+    const crlExt = AsnConvert.parse(asn.extnValue, CRLDistributionPoints);
+    this.distributionPoints = crlExt;
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    obj["Distribution Point"] = this.distributionPoints.map(dp => {
+      var _a;
+      const dpObj = {};
+      if (dp.distributionPoint) {
+        dpObj[""] = (_a = dp.distributionPoint.fullName) === null || _a === void 0 ? void 0 : _a.map(name => new GeneralName(name).toString()).join(", ");
+      }
+      if (dp.reasons) {
+        dpObj["Reasons"] = dp.reasons.toString();
+      }
+      if (dp.cRLIssuer) {
+        dpObj["CRL Issuer"] = dp.cRLIssuer.map(issuer => issuer.toString()).join(", ");
+      }
+      return dpObj;
+    });
+    return obj;
+  }
+}
+CRLDistributionPointsExtension.NAME = "CRL Distribution Points";
+class AuthorityInfoAccessExtension extends Extension {
+  constructor() {
+    var _a, _b, _c, _d;
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+    } else if ((arguments.length <= 0 ? undefined : arguments[0]) instanceof AuthorityInfoAccessSyntax) {
+      const value = new AuthorityInfoAccessSyntax(arguments.length <= 0 ? undefined : arguments[0]);
+      super(id_pe_authorityInfoAccess, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+    } else {
+      const params = arguments.length <= 0 ? undefined : arguments[0];
+      const value = new AuthorityInfoAccessSyntax();
+      addAccessDescriptions(value, params, id_ad_ocsp, "ocsp");
+      addAccessDescriptions(value, params, id_ad_caIssuers, "caIssuers");
+      addAccessDescriptions(value, params, id_ad_timeStamping, "timeStamping");
+      addAccessDescriptions(value, params, id_ad_caRepository, "caRepository");
+      super(id_pe_authorityInfoAccess, arguments.length <= 1 ? undefined : arguments[1], AsnConvert.serialize(value));
+    }
+    (_a = this.ocsp) !== null && _a !== void 0 ? _a : this.ocsp = [];
+    (_b = this.caIssuers) !== null && _b !== void 0 ? _b : this.caIssuers = [];
+    (_c = this.timeStamping) !== null && _c !== void 0 ? _c : this.timeStamping = [];
+    (_d = this.caRepository) !== null && _d !== void 0 ? _d : this.caRepository = [];
+  }
+  onInit(asn) {
+    super.onInit(asn);
+    this.ocsp = [];
+    this.caIssuers = [];
+    this.timeStamping = [];
+    this.caRepository = [];
+    const aia = AsnConvert.parse(asn.extnValue, AuthorityInfoAccessSyntax);
+    aia.forEach(accessDescription => {
+      switch (accessDescription.accessMethod) {
+        case id_ad_ocsp:
+          this.ocsp.push(new GeneralName(accessDescription.accessLocation));
+          break;
+        case id_ad_caIssuers:
+          this.caIssuers.push(new GeneralName(accessDescription.accessLocation));
+          break;
+        case id_ad_timeStamping:
+          this.timeStamping.push(new GeneralName(accessDescription.accessLocation));
+          break;
+        case id_ad_caRepository:
+          this.caRepository.push(new GeneralName(accessDescription.accessLocation));
+          break;
+      }
+    });
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    if (this.ocsp.length) {
+      addUrlsToObject(obj, "OCSP", this.ocsp);
+    }
+    if (this.caIssuers.length) {
+      addUrlsToObject(obj, "CA Issuers", this.caIssuers);
+    }
+    if (this.timeStamping.length) {
+      addUrlsToObject(obj, "Time Stamping", this.timeStamping);
+    }
+    if (this.caRepository.length) {
+      addUrlsToObject(obj, "CA Repository", this.caRepository);
+    }
+    return obj;
+  }
+}
+AuthorityInfoAccessExtension.NAME = "Authority Info Access";
+function addUrlsToObject(obj, key, urls) {
+  if (urls.length === 1) {
+    obj[key] = urls[0].toTextObject();
+  } else {
+    const names = new TextObject("");
+    urls.forEach((name, index) => {
+      const nameObj = name.toTextObject();
+      const indexedKey = `${nameObj[TextObject.NAME]} ${index + 1}`;
+      let field = names[indexedKey];
+      if (!Array.isArray(field)) {
+        field = [];
+        names[indexedKey] = field;
+      }
+      field.push(nameObj);
+    });
+    obj[key] = names;
+  }
+}
+function addAccessDescriptions(value, params, method, key) {
+  const items = params[key];
+  if (items) {
+    const array = Array.isArray(items) ? items : [items];
+    array.forEach(url => {
+      if (typeof url === "string") {
+        url = new GeneralName("url", url);
+      }
+      value.push(new AccessDescription({
+        accessMethod: method,
+        accessLocation: AsnConvert.parse(url.rawData, GeneralName$1)
+      }));
+    });
+  }
+}
+class Attribute extends AsnData {
+  constructor() {
+    let raw;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    if (buildExports.BufferSourceConverter.isBufferSource(args[0])) {
+      raw = buildExports.BufferSourceConverter.toArrayBuffer(args[0]);
+    } else {
+      const type = args[0];
+      const values = Array.isArray(args[1]) ? args[1].map(o => buildExports.BufferSourceConverter.toArrayBuffer(o)) : [];
+      raw = AsnConvert.serialize(new Attribute$1({
+        type,
+        values
+      }));
+    }
+    super(raw, Attribute$1);
+  }
+  onInit(asn) {
+    this.type = asn.type;
+    this.values = asn.values;
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    obj["Value"] = this.values.map(o => new TextObject("", {
+      "": o
+    }));
+    return obj;
+  }
+  toTextObjectWithoutValue() {
+    const obj = this.toTextObjectEmpty();
+    if (obj[TextObject.NAME] === Attribute.NAME) {
+      obj[TextObject.NAME] = OidSerializer.toString(this.type);
+    }
+    return obj;
+  }
+}
+Attribute.NAME = "Attribute";
+class ChallengePasswordAttribute extends Attribute {
+  constructor() {
+    var _a;
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+    } else {
+      const value = new ChallengePassword({
+        printableString: arguments.length <= 0 ? undefined : arguments[0]
+      });
+      super(id_pkcs9_at_challengePassword, [AsnConvert.serialize(value)]);
+    }
+    (_a = this.password) !== null && _a !== void 0 ? _a : this.password = "";
+  }
+  onInit(asn) {
+    super.onInit(asn);
+    if (this.values[0]) {
+      const value = AsnConvert.parse(this.values[0], ChallengePassword);
+      this.password = value.toString();
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    obj[TextObject.VALUE] = this.password;
+    return obj;
+  }
+}
+ChallengePasswordAttribute.NAME = "Challenge Password";
+class ExtensionsAttribute extends Attribute {
+  constructor() {
+    var _a;
+    if (buildExports.BufferSourceConverter.isBufferSource(arguments.length <= 0 ? undefined : arguments[0])) {
+      super(arguments.length <= 0 ? undefined : arguments[0]);
+    } else {
+      const extensions = arguments.length <= 0 ? undefined : arguments[0];
+      const value = new Extensions();
+      for (const extension of extensions) {
+        value.push(AsnConvert.parse(extension.rawData, Extension$1));
+      }
+      super(id_pkcs9_at_extensionRequest, [AsnConvert.serialize(value)]);
+    }
+    (_a = this.items) !== null && _a !== void 0 ? _a : this.items = [];
+  }
+  onInit(asn) {
+    super.onInit(asn);
+    if (this.values[0]) {
+      const value = AsnConvert.parse(this.values[0], Extensions);
+      this.items = value.map(o => ExtensionFactory.create(AsnConvert.serialize(o)));
+    }
+  }
+  toTextObject() {
+    const obj = this.toTextObjectWithoutValue();
+    const extensions = this.items.map(o => o.toTextObject());
+    for (const extension of extensions) {
+      obj[extension[TextObject.NAME]] = extension;
+    }
+    return obj;
+  }
+}
+ExtensionsAttribute.NAME = "Extensions";
+class AttributeFactory {
+  static register(id, type) {
+    this.items.set(id, type);
+  }
+  static create(data) {
+    const attribute = new Attribute(data);
+    const Type = this.items.get(attribute.type);
+    if (Type) {
+      return new Type(data);
+    }
+    return attribute;
+  }
+}
+AttributeFactory.items = new Map();
+const diAsnSignatureFormatter = "crypto.signatureFormatter";
+class AsnDefaultSignatureFormatter {
+  toAsnSignature(algorithm, signature) {
+    return buildExports.BufferSourceConverter.toArrayBuffer(signature);
+  }
+  toWebSignature(algorithm, signature) {
+    return buildExports.BufferSourceConverter.toArrayBuffer(signature);
+  }
+}
+var RsaAlgorithm_1;
+let RsaAlgorithm = RsaAlgorithm_1 = class RsaAlgorithm {
+  static createPssParams(hash, saltLength) {
+    const hashAlgorithm = RsaAlgorithm_1.getHashAlgorithm(hash);
+    if (!hashAlgorithm) {
+      return null;
+    }
+    return new RsaSaPssParams({
+      hashAlgorithm,
+      maskGenAlgorithm: new AlgorithmIdentifier({
+        algorithm: id_mgf1,
+        parameters: AsnConvert.serialize(hashAlgorithm)
+      }),
+      saltLength
+    });
+  }
+  static getHashAlgorithm(alg) {
+    const algProv = instance.resolve(diAlgorithmProvider);
+    if (typeof alg === "string") {
+      return algProv.toAsnAlgorithm({
+        name: alg
+      });
+    }
+    if (typeof alg === "object" && alg && "name" in alg) {
+      return algProv.toAsnAlgorithm(alg);
+    }
+    return null;
+  }
+  toAsnAlgorithm(alg) {
+    switch (alg.name.toLowerCase()) {
+      case "rsassa-pkcs1-v1_5":
+        if ("hash" in alg) {
+          let hash;
+          if (typeof alg.hash === "string") {
+            hash = alg.hash;
+          } else if (alg.hash && typeof alg.hash === "object" && "name" in alg.hash && typeof alg.hash.name === "string") {
+            hash = alg.hash.name.toUpperCase();
+          } else {
+            throw new Error("Cannot get hash algorithm name");
+          }
+          switch (hash.toLowerCase()) {
+            case "sha-1":
+              return new AlgorithmIdentifier({
+                algorithm: id_sha1WithRSAEncryption,
+                parameters: null
+              });
+            case "sha-256":
+              return new AlgorithmIdentifier({
+                algorithm: id_sha256WithRSAEncryption,
+                parameters: null
+              });
+            case "sha-384":
+              return new AlgorithmIdentifier({
+                algorithm: id_sha384WithRSAEncryption,
+                parameters: null
+              });
+            case "sha-512":
+              return new AlgorithmIdentifier({
+                algorithm: id_sha512WithRSAEncryption,
+                parameters: null
+              });
+          }
+        } else {
+          return new AlgorithmIdentifier({
+            algorithm: id_rsaEncryption,
+            parameters: null
+          });
+        }
+        break;
+      case "rsa-pss":
+        if ("hash" in alg) {
+          if (!("saltLength" in alg && typeof alg.saltLength === "number")) {
+            throw new Error("Cannot get 'saltLength' from 'alg' argument");
+          }
+          const pssParams = RsaAlgorithm_1.createPssParams(alg.hash, alg.saltLength);
+          if (!pssParams) {
+            throw new Error("Cannot create PSS parameters");
+          }
+          return new AlgorithmIdentifier({
+            algorithm: id_RSASSA_PSS,
+            parameters: AsnConvert.serialize(pssParams)
+          });
+        } else {
+          return new AlgorithmIdentifier({
+            algorithm: id_RSASSA_PSS,
+            parameters: null
+          });
+        }
+    }
+    return null;
+  }
+  toWebAlgorithm(alg) {
+    switch (alg.algorithm) {
+      case id_rsaEncryption:
+        return {
+          name: "RSASSA-PKCS1-v1_5"
+        };
+      case id_sha1WithRSAEncryption:
+        return {
+          name: "RSASSA-PKCS1-v1_5",
+          hash: {
+            name: "SHA-1"
+          }
+        };
+      case id_sha256WithRSAEncryption:
+        return {
+          name: "RSASSA-PKCS1-v1_5",
+          hash: {
+            name: "SHA-256"
+          }
+        };
+      case id_sha384WithRSAEncryption:
+        return {
+          name: "RSASSA-PKCS1-v1_5",
+          hash: {
+            name: "SHA-384"
+          }
+        };
+      case id_sha512WithRSAEncryption:
+        return {
+          name: "RSASSA-PKCS1-v1_5",
+          hash: {
+            name: "SHA-512"
+          }
+        };
+      case id_RSASSA_PSS:
+        if (alg.parameters) {
+          const pssParams = AsnConvert.parse(alg.parameters, RsaSaPssParams);
+          const algProv = instance.resolve(diAlgorithmProvider);
+          const hashAlg = algProv.toWebAlgorithm(pssParams.hashAlgorithm);
+          return {
+            name: "RSA-PSS",
+            hash: hashAlg,
+            saltLength: pssParams.saltLength
+          };
+        } else {
+          return {
+            name: "RSA-PSS"
+          };
+        }
+    }
+    return null;
+  }
+};
+RsaAlgorithm = RsaAlgorithm_1 = __decorate([injectable()], RsaAlgorithm);
+instance.registerSingleton(diAlgorithm, RsaAlgorithm);
+let ShaAlgorithm = class ShaAlgorithm {
+  toAsnAlgorithm(alg) {
+    switch (alg.name.toLowerCase()) {
+      case "sha-1":
+        return new AlgorithmIdentifier({
+          algorithm: id_sha1
+        });
+      case "sha-256":
+        return new AlgorithmIdentifier({
+          algorithm: id_sha256
+        });
+      case "sha-384":
+        return new AlgorithmIdentifier({
+          algorithm: id_sha384
+        });
+      case "sha-512":
+        return new AlgorithmIdentifier({
+          algorithm: id_sha512
+        });
+    }
+    return null;
+  }
+  toWebAlgorithm(alg) {
+    switch (alg.algorithm) {
+      case id_sha1:
+        return {
+          name: "SHA-1"
+        };
+      case id_sha256:
+        return {
+          name: "SHA-256"
+        };
+      case id_sha384:
+        return {
+          name: "SHA-384"
+        };
+      case id_sha512:
+        return {
+          name: "SHA-512"
+        };
+    }
+    return null;
+  }
+};
+ShaAlgorithm = __decorate([injectable()], ShaAlgorithm);
+instance.registerSingleton(diAlgorithm, ShaAlgorithm);
+class AsnEcSignatureFormatter {
+  addPadding(pointSize, data) {
+    const bytes = buildExports.BufferSourceConverter.toUint8Array(data);
+    const res = new Uint8Array(pointSize);
+    res.set(bytes, pointSize - bytes.length);
+    return res;
+  }
+  removePadding(data) {
+    let positive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let bytes = buildExports.BufferSourceConverter.toUint8Array(data);
+    for (let i = 0; i < bytes.length; i++) {
+      if (!bytes[i]) {
+        continue;
+      }
+      bytes = bytes.slice(i);
+      break;
+    }
+    if (positive && bytes[0] > 127) {
+      const result = new Uint8Array(bytes.length + 1);
+      result.set(bytes, 1);
+      return result.buffer;
+    }
+    return bytes.buffer;
+  }
+  toAsnSignature(algorithm, signature) {
+    if (algorithm.name === "ECDSA") {
+      const namedCurve = algorithm.namedCurve;
+      const pointSize = AsnEcSignatureFormatter.namedCurveSize.get(namedCurve) || AsnEcSignatureFormatter.defaultNamedCurveSize;
+      const ecSignature = new ECDSASigValue();
+      const uint8Signature = buildExports.BufferSourceConverter.toUint8Array(signature);
+      ecSignature.r = this.removePadding(uint8Signature.slice(0, pointSize), true);
+      ecSignature.s = this.removePadding(uint8Signature.slice(pointSize, pointSize + pointSize), true);
+      return AsnConvert.serialize(ecSignature);
+    }
+    return null;
+  }
+  toWebSignature(algorithm, signature) {
+    if (algorithm.name === "ECDSA") {
+      const ecSigValue = AsnConvert.parse(signature, ECDSASigValue);
+      const namedCurve = algorithm.namedCurve;
+      const pointSize = AsnEcSignatureFormatter.namedCurveSize.get(namedCurve) || AsnEcSignatureFormatter.defaultNamedCurveSize;
+      const r = this.addPadding(pointSize, this.removePadding(ecSigValue.r));
+      const s = this.addPadding(pointSize, this.removePadding(ecSigValue.s));
+      return buildExports.combine(r, s);
+    }
+    return null;
+  }
+}
+AsnEcSignatureFormatter.namedCurveSize = new Map();
+AsnEcSignatureFormatter.defaultNamedCurveSize = 32;
+const idX25519 = "1.3.101.110";
+const idX448 = "1.3.101.111";
+const idEd25519 = "1.3.101.112";
+const idEd448 = "1.3.101.113";
+let EdAlgorithm = class EdAlgorithm {
+  toAsnAlgorithm(alg) {
+    let algorithm = null;
+    switch (alg.name.toLowerCase()) {
+      case "ed25519":
+        algorithm = idEd25519;
+        break;
+      case "x25519":
+        algorithm = idX25519;
+        break;
+      case "eddsa":
+        switch (alg.namedCurve.toLowerCase()) {
+          case "ed25519":
+            algorithm = idEd25519;
+            break;
+          case "ed448":
+            algorithm = idEd448;
+            break;
+        }
+        break;
+      case "ecdh-es":
+        switch (alg.namedCurve.toLowerCase()) {
+          case "x25519":
+            algorithm = idX25519;
+            break;
+          case "x448":
+            algorithm = idX448;
+            break;
+        }
+    }
+    if (algorithm) {
+      return new AlgorithmIdentifier({
+        algorithm
+      });
+    }
+    return null;
+  }
+  toWebAlgorithm(alg) {
+    switch (alg.algorithm) {
+      case idEd25519:
+        return {
+          name: "Ed25519"
+        };
+      case idEd448:
+        return {
+          name: "EdDSA",
+          namedCurve: "Ed448"
+        };
+      case idX25519:
+        return {
+          name: "X25519"
+        };
+      case idX448:
+        return {
+          name: "ECDH-ES",
+          namedCurve: "X448"
+        };
+    }
+    return null;
+  }
+};
+EdAlgorithm = __decorate([injectable()], EdAlgorithm);
+instance.registerSingleton(diAlgorithm, EdAlgorithm);
+class Pkcs10CertificateRequest extends PemData {
+  constructor(param) {
+    if (PemData.isAsnEncoded(param)) {
+      super(param, CertificationRequest);
+    } else {
+      super(param);
+    }
+    this.tag = PemConverter.CertificateRequestTag;
+  }
+  onInit(asn) {
+    this.tbs = AsnConvert.serialize(asn.certificationRequestInfo);
+    this.publicKey = new PublicKey(asn.certificationRequestInfo.subjectPKInfo);
+    const algProv = instance.resolve(diAlgorithmProvider);
+    this.signatureAlgorithm = algProv.toWebAlgorithm(asn.signatureAlgorithm);
+    this.signature = asn.signature;
+    this.attributes = asn.certificationRequestInfo.attributes.map(o => AttributeFactory.create(AsnConvert.serialize(o)));
+    const extensions = this.getAttribute(id_pkcs9_at_extensionRequest);
+    this.extensions = [];
+    if (extensions instanceof ExtensionsAttribute) {
+      this.extensions = extensions.items;
+    }
+    this.subjectName = new Name(asn.certificationRequestInfo.subject);
+    this.subject = this.subjectName.toString();
+  }
+  getAttribute(type) {
+    for (const attr of this.attributes) {
+      if (attr.type === type) {
+        return attr;
+      }
+    }
+    return null;
+  }
+  getAttributes(type) {
+    return this.attributes.filter(o => o.type === type);
+  }
+  getExtension(type) {
+    for (const ext of this.extensions) {
+      if (ext.type === type) {
+        return ext;
+      }
+    }
+    return null;
+  }
+  getExtensions(type) {
+    return this.extensions.filter(o => o.type === type);
+  }
+  async verify() {
+    let crypto = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : cryptoProvider.get();
+    const algorithm = {
+      ...this.publicKey.algorithm,
+      ...this.signatureAlgorithm
+    };
+    const publicKey = await this.publicKey.export(algorithm, ["verify"], crypto);
+    const signatureFormatters = instance.resolveAll(diAsnSignatureFormatter).reverse();
+    let signature = null;
+    for (const signatureFormatter of signatureFormatters) {
+      signature = signatureFormatter.toWebSignature(algorithm, this.signature);
+      if (signature) {
+        break;
+      }
+    }
+    if (!signature) {
+      throw Error("Cannot convert WebCrypto signature value to ASN.1 format");
+    }
+    const ok = await crypto.subtle.verify(this.signatureAlgorithm, publicKey, signature, this.tbs);
+    return ok;
+  }
+  toTextObject() {
+    const obj = this.toTextObjectEmpty();
+    const req = AsnConvert.parse(this.rawData, CertificationRequest);
+    const tbs = req.certificationRequestInfo;
+    const data = new TextObject("", {
+      "Version": `${Version[tbs.version]} (${tbs.version})`,
+      "Subject": this.subject,
+      "Subject Public Key Info": this.publicKey
+    });
+    if (this.attributes.length) {
+      const attrs = new TextObject("");
+      for (const ext of this.attributes) {
+        const attrObj = ext.toTextObject();
+        attrs[attrObj[TextObject.NAME]] = attrObj;
+      }
+      data["Attributes"] = attrs;
+    }
+    obj["Data"] = data;
+    obj["Signature"] = new TextObject("", {
+      "Algorithm": TextConverter.serializeAlgorithm(req.signatureAlgorithm),
+      "": req.signature
+    });
+    return obj;
+  }
+}
+Pkcs10CertificateRequest.NAME = "PKCS#10 Certificate Request";
+class X509Certificate extends PemData {
+  constructor(param) {
+    if (PemData.isAsnEncoded(param)) {
+      super(param, Certificate);
+    } else {
+      super(param);
+    }
+    this.tag = PemConverter.CertificateTag;
+  }
+  onInit(asn) {
+    const tbs = asn.tbsCertificate;
+    this.tbs = AsnConvert.serialize(tbs);
+    this.serialNumber = buildExports.Convert.ToHex(tbs.serialNumber);
+    this.subjectName = new Name(tbs.subject);
+    this.subject = new Name(tbs.subject).toString();
+    this.issuerName = new Name(tbs.issuer);
+    this.issuer = this.issuerName.toString();
+    const algProv = instance.resolve(diAlgorithmProvider);
+    this.signatureAlgorithm = algProv.toWebAlgorithm(asn.signatureAlgorithm);
+    this.signature = asn.signatureValue;
+    const notBefore = tbs.validity.notBefore.utcTime || tbs.validity.notBefore.generalTime;
+    if (!notBefore) {
+      throw new Error("Cannot get 'notBefore' value");
+    }
+    this.notBefore = notBefore;
+    const notAfter = tbs.validity.notAfter.utcTime || tbs.validity.notAfter.generalTime;
+    if (!notAfter) {
+      throw new Error("Cannot get 'notAfter' value");
+    }
+    this.notAfter = notAfter;
+    this.extensions = [];
+    if (tbs.extensions) {
+      this.extensions = tbs.extensions.map(o => ExtensionFactory.create(AsnConvert.serialize(o)));
+    }
+    this.publicKey = new PublicKey(tbs.subjectPublicKeyInfo);
+  }
+  getExtension(type) {
+    for (const ext of this.extensions) {
+      if (typeof type === "string") {
+        if (ext.type === type) {
+          return ext;
+        }
+      } else {
+        if (ext instanceof type) {
+          return ext;
+        }
+      }
+    }
+    return null;
+  }
+  getExtensions(type) {
+    return this.extensions.filter(o => {
+      if (typeof type === "string") {
+        return o.type === type;
+      } else {
+        return o instanceof type;
+      }
+    });
+  }
+  async verify() {
+    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let crypto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : cryptoProvider.get();
+    let keyAlgorithm;
+    let publicKey;
+    const paramsKey = params.publicKey;
+    try {
+      if (!paramsKey) {
+        keyAlgorithm = {
+          ...this.publicKey.algorithm,
+          ...this.signatureAlgorithm
+        };
+        publicKey = await this.publicKey.export(keyAlgorithm, ["verify"], crypto);
+      } else if ("publicKey" in paramsKey) {
+        keyAlgorithm = {
+          ...paramsKey.publicKey.algorithm,
+          ...this.signatureAlgorithm
+        };
+        publicKey = await paramsKey.publicKey.export(keyAlgorithm, ["verify"], crypto);
+      } else if (paramsKey instanceof PublicKey) {
+        keyAlgorithm = {
+          ...paramsKey.algorithm,
+          ...this.signatureAlgorithm
+        };
+        publicKey = await paramsKey.export(keyAlgorithm, ["verify"], crypto);
+      } else if (buildExports.BufferSourceConverter.isBufferSource(paramsKey)) {
+        const key = new PublicKey(paramsKey);
+        keyAlgorithm = {
+          ...key.algorithm,
+          ...this.signatureAlgorithm
+        };
+        publicKey = await key.export(keyAlgorithm, ["verify"], crypto);
+      } else {
+        keyAlgorithm = {
+          ...paramsKey.algorithm,
+          ...this.signatureAlgorithm
+        };
+        publicKey = paramsKey;
+      }
+    } catch (e) {
+      return false;
+    }
+    const signatureFormatters = instance.resolveAll(diAsnSignatureFormatter).reverse();
+    let signature = null;
+    for (const signatureFormatter of signatureFormatters) {
+      signature = signatureFormatter.toWebSignature(keyAlgorithm, this.signature);
+      if (signature) {
+        break;
+      }
+    }
+    if (!signature) {
+      throw Error("Cannot convert ASN.1 signature value to WebCrypto format");
+    }
+    const ok = await crypto.subtle.verify(this.signatureAlgorithm, publicKey, signature, this.tbs);
+    if (params.signatureOnly) {
+      return ok;
+    } else {
+      const date = params.date || new Date();
+      const time = date.getTime();
+      return ok && this.notBefore.getTime() < time && time < this.notAfter.getTime();
+    }
+  }
+  async getThumbprint() {
+    let crypto;
+    let algorithm = "SHA-1";
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    if (args[0]) {
+      if (!args[0].subtle) {
+        algorithm = args[0] || algorithm;
+        crypto = args[1];
+      } else {
+        crypto = args[0];
+      }
+    }
+    crypto !== null && crypto !== void 0 ? crypto : crypto = cryptoProvider.get();
+    return await crypto.subtle.digest(algorithm, this.rawData);
+  }
+  async isSelfSigned() {
+    let crypto = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : cryptoProvider.get();
+    return this.subject === this.issuer && (await this.verify({
+      signatureOnly: true
+    }, crypto));
+  }
+  toTextObject() {
+    const obj = this.toTextObjectEmpty();
+    const cert = AsnConvert.parse(this.rawData, Certificate);
+    const tbs = cert.tbsCertificate;
+    const data = new TextObject("", {
+      "Version": `${Version[tbs.version]} (${tbs.version})`,
+      "Serial Number": tbs.serialNumber,
+      "Signature Algorithm": TextConverter.serializeAlgorithm(tbs.signature),
+      "Issuer": this.issuer,
+      "Validity": new TextObject("", {
+        "Not Before": tbs.validity.notBefore.getTime(),
+        "Not After": tbs.validity.notAfter.getTime()
+      }),
+      "Subject": this.subject,
+      "Subject Public Key Info": this.publicKey
+    });
+    if (tbs.issuerUniqueID) {
+      data["Issuer Unique ID"] = tbs.issuerUniqueID;
+    }
+    if (tbs.subjectUniqueID) {
+      data["Subject Unique ID"] = tbs.subjectUniqueID;
+    }
+    if (this.extensions.length) {
+      const extensions = new TextObject("");
+      for (const ext of this.extensions) {
+        const extObj = ext.toTextObject();
+        extensions[extObj[TextObject.NAME]] = extObj;
+      }
+      data["Extensions"] = extensions;
+    }
+    obj["Data"] = data;
+    obj["Signature"] = new TextObject("", {
+      "Algorithm": TextConverter.serializeAlgorithm(cert.signatureAlgorithm),
+      "": cert.signatureValue
+    });
+    return obj;
+  }
+}
+X509Certificate.NAME = "Certificate";
+class X509CertificateGenerator {
+  static async createSelfSigned(params) {
+    let crypto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : cryptoProvider.get();
+    if (!params.keys.privateKey) {
+      throw new Error("Bad field 'keys' in 'params' argument. 'privateKey' is empty");
+    }
+    if (!params.keys.publicKey) {
+      throw new Error("Bad field 'keys' in 'params' argument. 'publicKey' is empty");
+    }
+    return this.create({
+      serialNumber: params.serialNumber,
+      subject: params.name,
+      issuer: params.name,
+      notBefore: params.notBefore,
+      notAfter: params.notAfter,
+      publicKey: params.keys.publicKey,
+      signingKey: params.keys.privateKey,
+      signingAlgorithm: params.signingAlgorithm,
+      extensions: params.extensions
+    }, crypto);
+  }
+  static async create(params) {
+    let crypto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : cryptoProvider.get();
+    var _a;
+    let spki;
+    if (params.publicKey instanceof PublicKey) {
+      spki = params.publicKey.rawData;
+    } else if ("publicKey" in params.publicKey) {
+      spki = params.publicKey.publicKey.rawData;
+    } else if (buildExports.BufferSourceConverter.isBufferSource(params.publicKey)) {
+      spki = params.publicKey;
+    } else {
+      spki = await crypto.subtle.exportKey("spki", params.publicKey);
+    }
+    const serialNumber = params.serialNumber ? buildExports.BufferSourceConverter.toUint8Array(buildExports.Convert.FromHex(params.serialNumber)) : crypto.getRandomValues(new Uint8Array(16));
+    if (serialNumber[0] > 0x7F) {
+      serialNumber[0] &= 0x7F;
+    }
+    if (serialNumber.length > 1 && serialNumber[0] === 0) {
+      serialNumber[1] |= 0x80;
+    }
+    const notBefore = params.notBefore || new Date();
+    const notAfter = params.notAfter || new Date(notBefore.getTime() + 31536000000);
+    const asnX509 = new Certificate({
+      tbsCertificate: new TBSCertificate({
+        version: Version.v3,
+        serialNumber: serialNumber,
+        validity: new Validity({
+          notBefore,
+          notAfter
+        }),
+        extensions: new Extensions(((_a = params.extensions) === null || _a === void 0 ? void 0 : _a.map(o => AsnConvert.parse(o.rawData, Extension$1))) || []),
+        subjectPublicKeyInfo: AsnConvert.parse(spki, SubjectPublicKeyInfo)
+      })
+    });
+    if (params.subject) {
+      const name = params.subject instanceof Name ? params.subject : new Name(params.subject);
+      asnX509.tbsCertificate.subject = AsnConvert.parse(name.toArrayBuffer(), Name$1);
+    }
+    if (params.issuer) {
+      const name = params.issuer instanceof Name ? params.issuer : new Name(params.issuer);
+      asnX509.tbsCertificate.issuer = AsnConvert.parse(name.toArrayBuffer(), Name$1);
+    }
+    const defaultSigningAlgorithm = {
+      hash: "SHA-256"
+    };
+    const signatureAlgorithm = "signingKey" in params ? {
+      ...defaultSigningAlgorithm,
+      ...params.signingAlgorithm,
+      ...params.signingKey.algorithm
+    } : {
+      ...defaultSigningAlgorithm,
+      ...params.signingAlgorithm
+    };
+    const algProv = instance.resolve(diAlgorithmProvider);
+    asnX509.tbsCertificate.signature = asnX509.signatureAlgorithm = algProv.toAsnAlgorithm(signatureAlgorithm);
+    const tbs = AsnConvert.serialize(asnX509.tbsCertificate);
+    const signatureValue = "signingKey" in params ? await crypto.subtle.sign(signatureAlgorithm, params.signingKey, tbs) : params.signature;
+    const signatureFormatters = instance.resolveAll(diAsnSignatureFormatter).reverse();
+    let asnSignature = null;
+    for (const signatureFormatter of signatureFormatters) {
+      asnSignature = signatureFormatter.toAsnSignature(signatureAlgorithm, signatureValue);
+      if (asnSignature) {
+        break;
+      }
+    }
+    if (!asnSignature) {
+      throw Error("Cannot convert ASN.1 signature value to WebCrypto format");
+    }
+    asnX509.signatureValue = asnSignature;
+    return new X509Certificate(AsnConvert.serialize(asnX509));
+  }
+}
+var X509CrlReason;
+(function (X509CrlReason) {
+  X509CrlReason[X509CrlReason["unspecified"] = 0] = "unspecified";
+  X509CrlReason[X509CrlReason["keyCompromise"] = 1] = "keyCompromise";
+  X509CrlReason[X509CrlReason["cACompromise"] = 2] = "cACompromise";
+  X509CrlReason[X509CrlReason["affiliationChanged"] = 3] = "affiliationChanged";
+  X509CrlReason[X509CrlReason["superseded"] = 4] = "superseded";
+  X509CrlReason[X509CrlReason["cessationOfOperation"] = 5] = "cessationOfOperation";
+  X509CrlReason[X509CrlReason["certificateHold"] = 6] = "certificateHold";
+  X509CrlReason[X509CrlReason["removeFromCRL"] = 8] = "removeFromCRL";
+  X509CrlReason[X509CrlReason["privilegeWithdrawn"] = 9] = "privilegeWithdrawn";
+  X509CrlReason[X509CrlReason["aACompromise"] = 10] = "aACompromise";
+})(X509CrlReason || (X509CrlReason = {}));
+ExtensionFactory.register(id_ce_basicConstraints, BasicConstraintsExtension);
+ExtensionFactory.register(id_ce_extKeyUsage, ExtendedKeyUsageExtension);
+ExtensionFactory.register(id_ce_keyUsage, KeyUsagesExtension);
+ExtensionFactory.register(id_ce_subjectKeyIdentifier, SubjectKeyIdentifierExtension);
+ExtensionFactory.register(id_ce_authorityKeyIdentifier, AuthorityKeyIdentifierExtension);
+ExtensionFactory.register(id_ce_subjectAltName, SubjectAlternativeNameExtension);
+ExtensionFactory.register(id_ce_cRLDistributionPoints, CRLDistributionPointsExtension);
+ExtensionFactory.register(id_pe_authorityInfoAccess, AuthorityInfoAccessExtension);
+AttributeFactory.register(id_pkcs9_at_challengePassword, ChallengePasswordAttribute);
+AttributeFactory.register(id_pkcs9_at_extensionRequest, ExtensionsAttribute);
+instance.registerSingleton(diAsnSignatureFormatter, AsnDefaultSignatureFormatter);
+instance.registerSingleton(diAsnSignatureFormatter, AsnEcSignatureFormatter);
+AsnEcSignatureFormatter.namedCurveSize.set("P-256", 32);
+AsnEcSignatureFormatter.namedCurveSize.set("K-256", 32);
+AsnEcSignatureFormatter.namedCurveSize.set("P-384", 48);
+AsnEcSignatureFormatter.namedCurveSize.set("P-521", 66);
+
+export { AlgorithmProvider, AsnData, AsnDefaultSignatureFormatter, AsnEcSignatureFormatter, Attribute, AttributeFactory, AuthorityInfoAccessExtension, AuthorityKeyIdentifierExtension, BasicConstraintsExtension, CRLDistributionPointsExtension, CertificatePolicyExtension, ChallengePasswordAttribute, CryptoProvider, DefaultAlgorithmSerializer, EcAlgorithm, EdAlgorithm, ExtendedKeyUsage, ExtendedKeyUsageExtension, Extension, ExtensionFactory, ExtensionsAttribute, GeneralName, GeneralNames, KeyUsageFlags, KeyUsagesExtension, Name, NameIdentifier, OidSerializer, PemConverter, Pkcs10CertificateRequest, PublicKey, RsaAlgorithm, ShaAlgorithm, SubjectAlternativeNameExtension, SubjectKeyIdentifierExtension, TextConverter, TextObject, X509Certificate, X509CertificateGenerator, X509CrlReason, cryptoProvider, diAlgorithm, diAlgorithmProvider, diAsnSignatureFormatter, idEd25519, idEd448, idX25519, idX448 };