@peculiar/certificates-viewer 3.2.1 → 3.3.1

package/dist/esm/{certification_request-c0674647.js → certification_request-5b5c2fa2.js}

@@ -1,9 +1,8 @@
 /*!
  * © Peculiar Ventures https://peculiarventures.com/ - MIT License
  */
-import { b as build } from './index-0ba131b0.js';
-import './l10n-ac28fa92.js';
-import { c as createCommonjsModule, a as commonjsGlobal } from './_commonjsHelpers-bfbd2ad8.js';
+import { b as build, c as createCommonjsModule, a as commonjsGlobal } from './download-67ac9120.js';
+import './l10n-116c79fa.js';
 
 /**
  * @license
@@ -19,6 +18,8 @@ const isPem = (value) => (/-----BEGIN [^-]+-----([A-Za-z0-9+\/=\s]+)-----END [^-
   .test(value));
 const isX509Pem = (value) => (/-----BEGIN CERTIFICATE-----([A-Za-z0-9+\/=\s]+)-----END CERTIFICATE-----/
   .test(value));
+const isX509CRLPem = (value) => (/-----BEGIN X509 CRL-----([A-Za-z0-9+\/=\s]+)-----END X509 CRL-----/
+  .test(value));
 const isPkcs10Pem = (value) => (/-----BEGIN CERTIFICATE REQUEST-----([A-Za-z0-9+\/=\s]+)-----END CERTIFICATE REQUEST-----/
   .test(value));
 const isX509AttributePem = (value) => (/-----BEGIN ATTRIBUTE CERTIFICATE-----([A-Za-z0-9+\/=\s]+)-----END ATTRIBUTE CERTIFICATE-----/
@@ -3297,7 +3298,7 @@ function verifySchema(inputBuffer, inputSchema) {
     return compareSchema(asn1.result, asn1.result, inputSchema);
 }
 
-const asn1 = /*#__PURE__*/Object.freeze({
+const asn1js = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Any: Any,
   BaseBlock: BaseBlock,
@@ -3382,8 +3383,104 @@ var AsnPropTypes;
     AsnPropTypes[AsnPropTypes["Null"] = 27] = "Null";
 })(AsnPropTypes || (AsnPropTypes = {}));
 
+class BitString {
+    constructor(params, unusedBits = 0) {
+        this.unusedBits = 0;
+        this.value = new ArrayBuffer(0);
+        if (params) {
+            if (typeof params === "number") {
+                this.fromNumber(params);
+            }
+            else if (build.BufferSourceConverter.isBufferSource(params)) {
+                this.unusedBits = unusedBits;
+                this.value = build.BufferSourceConverter.toArrayBuffer(params);
+            }
+            else {
+                throw TypeError("Unsupported type of 'params' argument for BitString");
+            }
+        }
+    }
+    fromASN(asn) {
+        if (!(asn instanceof BitString$1)) {
+            throw new TypeError("Argument 'asn' is not instance of ASN.1 BitString");
+        }
+        this.unusedBits = asn.valueBlock.unusedBits;
+        this.value = asn.valueBlock.valueHex;
+        return this;
+    }
+    toASN() {
+        return new BitString$1({ unusedBits: this.unusedBits, valueHex: this.value });
+    }
+    toSchema(name) {
+        return new BitString$1({ name });
+    }
+    toNumber() {
+        let res = "";
+        const uintArray = new Uint8Array(this.value);
+        for (const octet of uintArray) {
+            res += octet.toString(2).padStart(8, "0");
+        }
+        res = res.split("").reverse().join("");
+        if (this.unusedBits) {
+            res = res.slice(this.unusedBits).padStart(this.unusedBits, "0");
+        }
+        return parseInt(res, 2);
+    }
+    fromNumber(value) {
+        let bits = value.toString(2);
+        const octetSize = (bits.length + 7) >> 3;
+        this.unusedBits = (octetSize << 3) - bits.length;
+        const octets = new Uint8Array(octetSize);
+        bits = bits.padStart(octetSize << 3, "0").split("").reverse().join("");
+        let index = 0;
+        while (index < octetSize) {
+            octets[index] = parseInt(bits.slice(index << 3, (index << 3) + 8), 2);
+            index++;
+        }
+        this.value = octets.buffer;
+    }
+}
+
+class OctetString {
+    constructor(param) {
+        if (typeof param === "number") {
+            this.buffer = new ArrayBuffer(param);
+        }
+        else {
+            if (build.BufferSourceConverter.isBufferSource(param)) {
+                this.buffer = build.BufferSourceConverter.toArrayBuffer(param);
+            }
+            else if (Array.isArray(param)) {
+                this.buffer = new Uint8Array(param);
+            }
+            else {
+                this.buffer = new ArrayBuffer(0);
+            }
+        }
+    }
+    get byteLength() {
+        return this.buffer.byteLength;
+    }
+    get byteOffset() {
+        return 0;
+    }
+    fromASN(asn) {
+        if (!(asn instanceof OctetString$1)) {
+            throw new TypeError("Argument 'asn' is not instance of ASN.1 OctetString");
+        }
+        this.buffer = asn.valueBlock.valueHex;
+        return this;
+    }
+    toASN() {
+        return new OctetString$1({ valueHex: this.buffer });
+    }
+    toSchema(name) {
+        return new OctetString$1({ name });
+    }
+}
+
 const AsnAnyConverter = {
-    fromASN: (value) => value instanceof Null ? null : value.valueBeforeDecode,
+    fromASN: (value) => value instanceof Null ? null : value.valueBeforeDecodeView,
     toASN: (value) => {
         if (value === null) {
             return new Null();
@@ -3396,21 +3493,21 @@ const AsnAnyConverter = {
     },
 };
 const AsnIntegerConverter = {
-    fromASN: (value) => value.valueBlock.valueHex.byteLength > 4
+    fromASN: (value) => value.valueBlock.valueHexView.byteLength >= 4
         ? value.valueBlock.toString()
         : value.valueBlock.valueDec,
-    toASN: (value) => new Integer({ value: value }),
+    toASN: (value) => new Integer({ value: +value }),
 };
 const AsnEnumeratedConverter = {
     fromASN: (value) => value.valueBlock.valueDec,
     toASN: (value) => new Enumerated({ value }),
 };
 const AsnIntegerArrayBufferConverter = {
-    fromASN: (value) => value.valueBlock.valueHex,
+    fromASN: (value) => value.valueBlock.valueHexView,
     toASN: (value) => new Integer({ valueHex: value }),
 };
 const AsnBitStringConverter = {
-    fromASN: (value) => value.valueBlock.valueHex,
+    fromASN: (value) => value.valueBlock.valueHexView,
     toASN: (value) => new BitString$1({ valueHex: value }),
 };
 const AsnObjectIdentifierConverter = {
@@ -3422,9 +3519,13 @@ const AsnBooleanConverter = {
     toASN: (value) => new Boolean({ value }),
 };
 const AsnOctetStringConverter = {
-    fromASN: (value) => value.valueBlock.valueHex,
+    fromASN: (value) => value.valueBlock.valueHexView,
     toASN: (value) => new OctetString$1({ valueHex: value }),
 };
+const AsnConstructedOctetStringConverter = {
+    fromASN: (value) => new OctetString(value.getValue()),
+    toASN: (value) => value.toASN(),
+};
 function createStringConverter(Asn1Type) {
     return {
         fromASN: (value) => value.valueBlock.value,
@@ -3452,8 +3553,8 @@ const AsnGeneralizedTimeConverter = {
     toASN: (value) => new GeneralizedTime({ valueDate: value }),
 };
 const AsnNullConverter = {
-    fromASN: (value) => null,
-    toASN: (value) => {
+    fromASN: () => null,
+    toASN: () => {
         return new Null();
     },
 };
@@ -3508,104 +3609,8 @@ function defaultConverter(type) {
     }
 }
 
-class BitString {
-    constructor(params, unusedBits = 0) {
-        this.unusedBits = 0;
-        this.value = new ArrayBuffer(0);
-        if (params) {
-            if (typeof params === "number") {
-                this.fromNumber(params);
-            }
-            else if (build.BufferSourceConverter.isBufferSource(params)) {
-                this.unusedBits = unusedBits;
-                this.value = build.BufferSourceConverter.toArrayBuffer(params);
-            }
-            else {
-                throw TypeError("Unsupported type of 'params' argument for BitString");
-            }
-        }
-    }
-    fromASN(asn) {
-        if (!(asn instanceof BitString$1)) {
-            throw new TypeError("Argument 'asn' is not instance of ASN.1 BitString");
-        }
-        this.unusedBits = asn.valueBlock.unusedBits;
-        this.value = asn.valueBlock.valueHex;
-        return this;
-    }
-    toASN() {
-        return new BitString$1({ unusedBits: this.unusedBits, valueHex: this.value });
-    }
-    toSchema(name) {
-        return new BitString$1({ name });
-    }
-    toNumber() {
-        let res = "";
-        const uintArray = new Uint8Array(this.value);
-        for (const octet of uintArray) {
-            res += octet.toString(2).padStart(8, "0");
-        }
-        res = res.split("").reverse().join("");
-        if (this.unusedBits) {
-            res = res.slice(this.unusedBits).padStart(this.unusedBits, "0");
-        }
-        return parseInt(res, 2);
-    }
-    fromNumber(value) {
-        let bits = value.toString(2);
-        const octetSize = (bits.length + 7) >> 3;
-        this.unusedBits = (octetSize << 3) - bits.length;
-        const octets = new Uint8Array(octetSize);
-        bits = bits.padStart(octetSize << 3, "0").split("").reverse().join("");
-        let index = 0;
-        while (index < octetSize) {
-            octets[index] = parseInt(bits.slice(index << 3, (index << 3) + 8), 2);
-            index++;
-        }
-        this.value = octets.buffer;
-    }
-}
-
-class OctetString {
-    constructor(param) {
-        if (typeof param === "number") {
-            this.buffer = new ArrayBuffer(param);
-        }
-        else {
-            if (build.BufferSourceConverter.isBufferSource(param)) {
-                this.buffer = build.BufferSourceConverter.toArrayBuffer(param);
-            }
-            else if (Array.isArray(param)) {
-                this.buffer = new Uint8Array(param);
-            }
-            else {
-                this.buffer = new ArrayBuffer(0);
-            }
-        }
-    }
-    get byteLength() {
-        return this.buffer.byteLength;
-    }
-    get byteOffset() {
-        return 0;
-    }
-    fromASN(asn) {
-        if (!(asn instanceof OctetString$1)) {
-            throw new TypeError("Argument 'asn' is not instance of ASN.1 OctetString");
-        }
-        this.buffer = asn.valueBlock.valueHex;
-        return this;
-    }
-    toASN() {
-        return new OctetString$1({ valueHex: this.buffer });
-    }
-    toSchema(name) {
-        return new OctetString$1({ name });
-    }
-}
-
 function isConvertible(target) {
-    if (target && target.prototype) {
+    if (typeof target === "function" && target.prototype) {
         if (target.prototype.toASN && target.prototype.fromASN) {
             return true;
         }
@@ -3614,7 +3619,7 @@ function isConvertible(target) {
         }
     }
     else {
-        return !!(target && target.toASN && target.fromASN);
+        return !!(target && typeof target === "object" && "toASN" in target && "fromASN" in target);
     }
 }
 function isTypeOfArray(target) {
@@ -3652,11 +3657,13 @@ class AsnSchemaStorage {
     has(target) {
         return this.items.has(target);
     }
-    get(target) {
-        var _a, _b, _c;
+    get(target, checkSchema = false) {
         const schema = this.items.get(target);
         if (!schema) {
-            throw new Error(`Cannot get schema for '${(_c = (_b = (_a = target === null || target === void 0 ? void 0 : target.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : target}' target`);
+            throw new Error(`Cannot get schema for '${target.prototype.constructor.name}' target`);
+        }
+        if (checkSchema && !schema.schema) {
+            throw new Error(`Schema '${target.prototype.constructor.name}' doesn't contain ASN.1 schema. Call 'AsnSchemaStorage.cache'.`);
         }
         return schema;
     }
@@ -3687,7 +3694,7 @@ class AsnSchemaStorage {
             let asn1Item;
             if (typeof (item.type) === "number") {
                 const Asn1TypeName = AsnPropTypes[item.type];
-                const Asn1Type = asn1[Asn1TypeName];
+                const Asn1Type = asn1js[Asn1TypeName];
                 if (!Asn1Type) {
                     throw new Error(`Cannot get ASN1 class by name '${Asn1TypeName}'`);
                 }
@@ -3745,9 +3752,9 @@ class AsnSchemaStorage {
                         this.cache(item.type);
                         const isRepeated = !!item.repeated;
                         let value = !isRepeated
-                            ? this.get(item.type).schema
+                            ? this.get(item.type, true).schema
                             : asn1Item;
-                        value = value.valueBlock ? value.valueBlock.value : value.value;
+                        value = "valueBlock" in value ? value.valueBlock.value : value.value;
                         asn1Value.push(new Constructed({
                             name: !isRepeated ? name : "",
                             optional,
@@ -3755,7 +3762,7 @@ class AsnSchemaStorage {
                                 tagClass: 3,
                                 tagNumber: item.context,
                             },
-                            value,
+                            value: value,
                         }));
                     }
                 }
@@ -3791,7 +3798,7 @@ class AsnSchemaStorage {
         return this;
     }
     findParentSchema(target) {
-        const parent = target.__proto__;
+        const parent = Object.getPrototypeOf(target);
         if (parent) {
             const schema = this.items.get(parent);
             return schema || this.findParentSchema(parent);
@@ -3877,15 +3884,19 @@ class AsnParser {
             }
             const res = new target();
             if (isTypeOfArray(target)) {
-                if (typeof schema.itemType === "number") {
-                    const converter = defaultConverter(schema.itemType);
+                if (!("value" in asn1Schema.valueBlock && Array.isArray(asn1Schema.valueBlock.value))) {
+                    throw new Error(`Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.`);
+                }
+                const itemType = schema.itemType;
+                if (typeof itemType === "number") {
+                    const converter = defaultConverter(itemType);
                     if (!converter) {
                         throw new Error(`Cannot get default converter for array item of ${target.name} ASN1 schema`);
                     }
                     return target.from(asn1Schema.valueBlock.value, (element) => converter.fromASN(element));
                 }
                 else {
-                    return target.from(asn1Schema.valueBlock.value, (element) => this.fromASN(element, schema.itemType));
+                    return target.from(asn1Schema.valueBlock.value, (element) => this.fromASN(element, itemType));
                 }
             }
             for (const key in schema.items) {
@@ -3894,9 +3905,10 @@ class AsnParser {
                     continue;
                 }
                 const schemaItem = schema.items[key];
-                if (typeof (schemaItem.type) === "number" || isConvertible(schemaItem.type)) {
-                    const converter = (_a = schemaItem.converter) !== null && _a !== void 0 ? _a : (isConvertible(schemaItem.type)
-                        ? new schemaItem.type()
+                const schemaItemType = schemaItem.type;
+                if (typeof schemaItemType === "number" || isConvertible(schemaItemType)) {
+                    const converter = (_a = schemaItem.converter) !== null && _a !== void 0 ? _a : (isConvertible(schemaItemType)
+                        ? new schemaItemType()
                         : null);
                     if (!converter) {
                         throw new Error("Converter is empty");
@@ -3908,7 +3920,14 @@ class AsnParser {
                                 : Set;
                             const newItem = new Container();
                             newItem.valueBlock = asn1SchemaValue.valueBlock;
-                            const value = fromBER(newItem.toBER(false)).result.valueBlock.value;
+                            const newItemAsn = fromBER(newItem.toBER(false));
+                            if (newItemAsn.offset === -1) {
+                                throw new Error(`Cannot parse the child item. ${newItemAsn.result.error}`);
+                            }
+                            if (!("value" in newItemAsn.result.valueBlock && Array.isArray(newItemAsn.result.valueBlock.value))) {
+                                throw new Error("Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.");
+                            }
+                            const value = newItemAsn.result.valueBlock.value;
                             res[key] = Array.from(value, (element) => converter.fromASN(element));
                         }
                         else {
@@ -3919,12 +3938,12 @@ class AsnParser {
                         let value = asn1SchemaValue;
                         if (schemaItem.implicit) {
                             let newItem;
-                            if (isConvertible(schemaItem.type)) {
-                                newItem = new schemaItem.type().toSchema("");
+                            if (isConvertible(schemaItemType)) {
+                                newItem = new schemaItemType().toSchema("");
                             }
                             else {
-                                const Asn1TypeName = AsnPropTypes[schemaItem.type];
-                                const Asn1Type = asn1[Asn1TypeName];
+                                const Asn1TypeName = AsnPropTypes[schemaItemType];
+                                const Asn1Type = asn1js[Asn1TypeName];
                                 if (!Asn1Type) {
                                     throw new Error(`Cannot get '${Asn1TypeName}' class from asn1js module`);
                                 }
@@ -3938,10 +3957,13 @@ class AsnParser {
                 }
                 else {
                     if (schemaItem.repeated) {
-                        res[key] = Array.from(asn1SchemaValue, (element) => this.fromASN(element, schemaItem.type));
+                        if (!Array.isArray(asn1SchemaValue)) {
+                            throw new Error("Cannot get list of items from the ASN.1 parsed value. ASN.1 value should be iterable.");
+                        }
+                        res[key] = Array.from(asn1SchemaValue, (element) => this.fromASN(element, schemaItemType));
                     }
                     else {
-                        res[key] = this.fromASN(asn1SchemaValue, schemaItem.type);
+                        res[key] = this.fromASN(asn1SchemaValue, schemaItemType);
                     }
                 }
             }
@@ -3964,14 +3986,20 @@ class AsnSerializer {
         return this.toASN(obj).toBER(false);
     }
     static toASN(obj) {
-        if (obj && isConvertible(obj.constructor)) {
+        if (obj && typeof obj === "object" && isConvertible(obj)) {
             return obj.toASN();
         }
+        if (!(obj && typeof obj === "object")) {
+            throw new TypeError("Parameter 1 should be type of Object.");
+        }
         const target = obj.constructor;
         const schema = schemaStorage.get(target);
         schemaStorage.cache(target);
         let asn1Value = [];
         if (schema.itemType) {
+            if (!Array.isArray(obj)) {
+                throw new TypeError("Parameter 1 should be type of Array.");
+            }
             if (typeof schema.itemType === "number") {
                 const converter = defaultConverter(schema.itemType);
                 if (!converter) {
@@ -3993,13 +4021,13 @@ class AsnSerializer {
                         && isArrayEqual(this.serialize(schemaItem.defaultValue), this.serialize(objProp)))) {
                     continue;
                 }
-                let asn1Item = AsnSerializer.toAsnItem(schemaItem, key, target, objProp);
+                const asn1Item = AsnSerializer.toAsnItem(schemaItem, key, target, objProp);
                 if (typeof schemaItem.context === "number") {
                     if (schemaItem.implicit) {
                         if (!schemaItem.repeated
                             && (typeof schemaItem.type === "number" || isConvertible(schemaItem.type))) {
                             const value = {};
-                            value.valueHex = asn1Item instanceof Null ? asn1Item.valueBeforeDecode : asn1Item.valueBlock.toBER();
+                            value.valueHex = asn1Item instanceof Null ? asn1Item.valueBeforeDecodeView : asn1Item.valueBlock.toBER();
                             asn1Value.push(new Primitive({
                                 optional: schemaItem.optional,
                                 idBlock: {
@@ -4064,6 +4092,9 @@ class AsnSerializer {
                 throw new Error(`Property '${key}' doesn't have converter for type ${AsnPropTypes[schemaItem.type]} in schema '${target.name}'`);
             }
             if (schemaItem.repeated) {
+                if (!Array.isArray(objProp)) {
+                    throw new TypeError("Parameter 'objProp' should be type of Array.");
+                }
                 const items = Array.from(objProp, (element) => converter.toASN(element));
                 const Container = schemaItem.repeated === "sequence"
                     ? Sequence
@@ -4078,6 +4109,9 @@ class AsnSerializer {
         }
         else {
             if (schemaItem.repeated) {
+                if (!Array.isArray(objProp)) {
+                    throw new TypeError("Parameter 'objProp' should be type of Array.");
+                }
                 const items = Array.from(objProp, (element) => this.toASN(element));
                 const Container = schemaItem.repeated === "sequence"
                     ? Sequence
@@ -5429,7 +5463,7 @@ let DisplayText = class DisplayText {
         Object.assign(this, params);
     }
     toString() {
-        return this.ia5String || this.visibleString || this.bmpString || this.utf8String;
+        return this.ia5String || this.visibleString || this.bmpString || this.utf8String || "";
     }
 };
 __decorate([
@@ -5520,6 +5554,7 @@ CertificatePolicies = CertificatePolicies_1 = __decorate([
     AsnType({ type: AsnTypeTypes.Sequence, itemType: PolicyInformation })
 ], CertificatePolicies);
 
+const id_ce_cRLNumber = `${id_ce}.20`;
 let CRLNumber = class CRLNumber {
     constructor(value = 0) {
         this.value = value;
@@ -5532,6 +5567,7 @@ CRLNumber = __decorate([
     AsnType({ type: AsnTypeTypes.Choice })
 ], CRLNumber);
 
+const id_ce_deltaCRLIndicator = `${id_ce}.27`;
 let BaseCRLNumber = class BaseCRLNumber extends CRLNumber {
 };
 BaseCRLNumber = __decorate([
@@ -5638,6 +5674,7 @@ FreshestCRL = FreshestCRL_1 = __decorate([
     AsnType({ type: AsnTypeTypes.Sequence, itemType: DistributionPoint })
 ], FreshestCRL);
 
+const id_ce_issuingDistributionPoint = `${id_ce}.28`;
 class IssuingDistributionPoint {
     constructor(params = {}) {
         this.onlyContainsUserCerts = IssuingDistributionPoint.ONLY;
@@ -5646,29 +5683,25 @@ class IssuingDistributionPoint {
         this.onlyContainsAttributeCerts = IssuingDistributionPoint.ONLY;
         Object.assign(this, params);
     }
-    ;
-    ;
-    ;
-    ;
 }
 IssuingDistributionPoint.ONLY = false;
 __decorate([
     AsnProp({ type: DistributionPointName, context: 0, optional: true })
 ], IssuingDistributionPoint.prototype, "distributionPoint", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Boolean, context: 1, defaultValue: IssuingDistributionPoint.ONLY })
+    AsnProp({ type: AsnPropTypes.Boolean, context: 1, defaultValue: IssuingDistributionPoint.ONLY, implicit: true })
 ], IssuingDistributionPoint.prototype, "onlyContainsUserCerts", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Boolean, context: 2, defaultValue: IssuingDistributionPoint.ONLY })
+    AsnProp({ type: AsnPropTypes.Boolean, context: 2, defaultValue: IssuingDistributionPoint.ONLY, implicit: true })
 ], IssuingDistributionPoint.prototype, "onlyContainsCACerts", void 0);
 __decorate([
-    AsnProp({ type: Reason, context: 3, optional: true })
+    AsnProp({ type: Reason, context: 3, optional: true, implicit: true })
 ], IssuingDistributionPoint.prototype, "onlySomeReasons", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Boolean, context: 4, defaultValue: IssuingDistributionPoint.ONLY })
+    AsnProp({ type: AsnPropTypes.Boolean, context: 4, defaultValue: IssuingDistributionPoint.ONLY, implicit: true })
 ], IssuingDistributionPoint.prototype, "indirectCRL", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Boolean, context: 5, defaultValue: IssuingDistributionPoint.ONLY })
+    AsnProp({ type: AsnPropTypes.Boolean, context: 5, defaultValue: IssuingDistributionPoint.ONLY, implicit: true })
 ], IssuingDistributionPoint.prototype, "onlyContainsAttributeCerts", void 0);
 
 const id_ce_cRLReasons = `${id_ce}.21`;
@@ -6041,11 +6074,14 @@ __decorate([
 let Time = class Time {
     constructor(time) {
         if (time) {
-            if (typeof time === "string" || typeof time === "number") {
-                this.utcTime = new Date(time);
-            }
-            else if (time instanceof Date) {
-                this.utcTime = time;
+            if (typeof time === "string" || typeof time === "number" || time instanceof Date) {
+                const date = new Date(time);
+                if (date.getUTCFullYear() > 2049) {
+                    this.generalTime = date;
+                }
+                else {
+                    this.utcTime = date;
+                }
             }
             else {
                 Object.assign(this, time);
@@ -10053,6 +10089,9 @@ class Extension extends AsnData {
         case '2.5.29.46':
           this.value = AsnParser.parse(asnExtnValue, CRLDistributionPoints);
           break;
+        case id_ce_issuingDistributionPoint:
+          this.value = AsnParser.parse(asnExtnValue, IssuingDistributionPoint);
+          break;
         case id_ce_cRLReasons:
           this.value = AsnParser.parse(asnExtnValue, CRLReason);
           break;
@@ -10141,6 +10180,12 @@ class Extension extends AsnData {
         case id_pe_subjectInfoAccess:
           this.value = AsnParser.parse(asnExtnValue, SubjectInfoAccessSyntax);
           break;
+        case id_ce_cRLNumber:
+          this.value = AsnParser.parse(asnExtnValue, CRLNumber);
+          break;
+        case id_ce_deltaCRLIndicator:
+          this.value = AsnParser.parse(asnExtnValue, BaseCRLNumber);
+          break;
         default:
           console.warn(`Didn't detect parser for "${this.asn.extnID}" extension.`);
           this.value = build.Convert.ToHex(asnExtnValue);
@@ -10197,10 +10242,11 @@ class CryptoProvider {
 CryptoProvider.DEFAULT = 'default';
 const cryptoProvider = new CryptoProvider();
 
-const base64Clarify = (base64) => (base64
-  .replace(/.*base64,/, '')
-  .replace(/-----.+-----/g, '')
-  .replace(/[\s\r\n]/g, ''));
+const base64Re = /-----BEGIN [^-]+-----([A-Za-z0-9+/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+/=\s]+)====/;
+const base64Clarify = (base64) => {
+  const execArray = base64Re.exec(base64);
+  return execArray ? (execArray[1] || execArray[2]) : base64;
+};
 const hexFormat = (hex) => (hex
   .replace(/(.{32})/g, '$1\n')
   .replace(/(.{4})/g, '$1 ')
@@ -10881,6 +10927,77 @@ __decorate([
     AsnProp({ type: EncapsulatedContent, context: 0, optional: true })
 ], EncapsulatedContentInfo.prototype, "eContent", void 0);
 
+var CMSVersion;
+(function (CMSVersion) {
+    CMSVersion[CMSVersion["v0"] = 0] = "v0";
+    CMSVersion[CMSVersion["v1"] = 1] = "v1";
+    CMSVersion[CMSVersion["v2"] = 2] = "v2";
+    CMSVersion[CMSVersion["v3"] = 3] = "v3";
+    CMSVersion[CMSVersion["v4"] = 4] = "v4";
+    CMSVersion[CMSVersion["v5"] = 5] = "v5";
+})(CMSVersion || (CMSVersion = {}));
+let DigestAlgorithmIdentifier = class DigestAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+DigestAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], DigestAlgorithmIdentifier);
+let SignatureAlgorithmIdentifier = class SignatureAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+SignatureAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], SignatureAlgorithmIdentifier);
+let KeyEncryptionAlgorithmIdentifier = class KeyEncryptionAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+KeyEncryptionAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], KeyEncryptionAlgorithmIdentifier);
+let ContentEncryptionAlgorithmIdentifier = class ContentEncryptionAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+ContentEncryptionAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], ContentEncryptionAlgorithmIdentifier);
+let MessageAuthenticationCodeAlgorithm = class MessageAuthenticationCodeAlgorithm extends AlgorithmIdentifier {
+};
+MessageAuthenticationCodeAlgorithm = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], MessageAuthenticationCodeAlgorithm);
+let KeyDerivationAlgorithmIdentifier = class KeyDerivationAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+KeyDerivationAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], KeyDerivationAlgorithmIdentifier);
+
+let EncryptedContent = class EncryptedContent {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+};
+__decorate([
+    AsnProp({ type: OctetString, context: 0, implicit: true, optional: true })
+], EncryptedContent.prototype, "value", void 0);
+__decorate([
+    AsnProp({ type: OctetString, converter: AsnConstructedOctetStringConverter, context: 0, implicit: true, optional: true, repeated: "sequence" })
+], EncryptedContent.prototype, "constructedValue", void 0);
+EncryptedContent = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], EncryptedContent);
+class EncryptedContentInfo {
+    constructor(params = {}) {
+        this.contentType = "";
+        this.contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.ObjectIdentifier })
+], EncryptedContentInfo.prototype, "contentType", void 0);
+__decorate([
+    AsnProp({ type: ContentEncryptionAlgorithmIdentifier })
+], EncryptedContentInfo.prototype, "contentEncryptionAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: EncryptedContent, optional: true })
+], EncryptedContentInfo.prototype, "encryptedContent", void 0);
+
 class IssuerAndSerialNumber {
     constructor(params = {}) {
         this.issuer = new Name$1;
@@ -10895,6 +11012,268 @@ __decorate([
     AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter })
 ], IssuerAndSerialNumber.prototype, "serialNumber", void 0);
 
+class OtherKeyAttribute {
+    constructor(params = {}) {
+        this.keyAttrId = "";
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.ObjectIdentifier })
+], OtherKeyAttribute.prototype, "keyAttrId", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Any, optional: true })
+], OtherKeyAttribute.prototype, "keyAttr", void 0);
+
+var RecipientEncryptedKeys_1;
+class RecipientKeyIdentifier {
+    constructor(params = {}) {
+        this.subjectKeyIdentifier = new SubjectKeyIdentifier();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: SubjectKeyIdentifier })
+], RecipientKeyIdentifier.prototype, "subjectKeyIdentifier", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.GeneralizedTime, optional: true })
+], RecipientKeyIdentifier.prototype, "date", void 0);
+__decorate([
+    AsnProp({ type: OtherKeyAttribute, optional: true })
+], RecipientKeyIdentifier.prototype, "other", void 0);
+let KeyAgreeRecipientIdentifier = class KeyAgreeRecipientIdentifier {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+};
+__decorate([
+    AsnProp({ type: RecipientKeyIdentifier, context: 0, implicit: true, optional: true })
+], KeyAgreeRecipientIdentifier.prototype, "rKeyId", void 0);
+__decorate([
+    AsnProp({ type: IssuerAndSerialNumber, optional: true })
+], KeyAgreeRecipientIdentifier.prototype, "issuerAndSerialNumber", void 0);
+KeyAgreeRecipientIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], KeyAgreeRecipientIdentifier);
+class RecipientEncryptedKey {
+    constructor(params = {}) {
+        this.rid = new KeyAgreeRecipientIdentifier();
+        this.encryptedKey = new OctetString();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: KeyAgreeRecipientIdentifier })
+], RecipientEncryptedKey.prototype, "rid", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], RecipientEncryptedKey.prototype, "encryptedKey", void 0);
+let RecipientEncryptedKeys = RecipientEncryptedKeys_1 = class RecipientEncryptedKeys extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, RecipientEncryptedKeys_1.prototype);
+    }
+};
+RecipientEncryptedKeys = RecipientEncryptedKeys_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence, itemType: RecipientEncryptedKey })
+], RecipientEncryptedKeys);
+class OriginatorPublicKey {
+    constructor(params = {}) {
+        this.algorithm = new AlgorithmIdentifier();
+        this.publicKey = new ArrayBuffer(0);
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AlgorithmIdentifier })
+], OriginatorPublicKey.prototype, "algorithm", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.BitString })
+], OriginatorPublicKey.prototype, "publicKey", void 0);
+let OriginatorIdentifierOrKey = class OriginatorIdentifierOrKey {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+};
+__decorate([
+    AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true, optional: true })
+], OriginatorIdentifierOrKey.prototype, "subjectKeyIdentifier", void 0);
+__decorate([
+    AsnProp({ type: OriginatorPublicKey, context: 1, implicit: true, optional: true })
+], OriginatorIdentifierOrKey.prototype, "originatorKey", void 0);
+__decorate([
+    AsnProp({ type: IssuerAndSerialNumber, optional: true })
+], OriginatorIdentifierOrKey.prototype, "issuerAndSerialNumber", void 0);
+OriginatorIdentifierOrKey = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], OriginatorIdentifierOrKey);
+class KeyAgreeRecipientInfo {
+    constructor(params = {}) {
+        this.version = CMSVersion.v3;
+        this.originator = new OriginatorIdentifierOrKey();
+        this.keyEncryptionAlgorithm = new KeyEncryptionAlgorithmIdentifier();
+        this.recipientEncryptedKeys = new RecipientEncryptedKeys();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], KeyAgreeRecipientInfo.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: OriginatorIdentifierOrKey, context: 0 })
+], KeyAgreeRecipientInfo.prototype, "originator", void 0);
+__decorate([
+    AsnProp({ type: OctetString, context: 1, optional: true })
+], KeyAgreeRecipientInfo.prototype, "ukm", void 0);
+__decorate([
+    AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
+], KeyAgreeRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: RecipientEncryptedKeys })
+], KeyAgreeRecipientInfo.prototype, "recipientEncryptedKeys", void 0);
+
+let RecipientIdentifier = class RecipientIdentifier {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+};
+__decorate([
+    AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true })
+], RecipientIdentifier.prototype, "subjectKeyIdentifier", void 0);
+__decorate([
+    AsnProp({ type: IssuerAndSerialNumber })
+], RecipientIdentifier.prototype, "issuerAndSerialNumber", void 0);
+RecipientIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], RecipientIdentifier);
+class KeyTransRecipientInfo {
+    constructor(params = {}) {
+        this.version = CMSVersion.v0;
+        this.rid = new RecipientIdentifier();
+        this.keyEncryptionAlgorithm = new KeyEncryptionAlgorithmIdentifier();
+        this.encryptedKey = new OctetString();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], KeyTransRecipientInfo.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: RecipientIdentifier })
+], KeyTransRecipientInfo.prototype, "rid", void 0);
+__decorate([
+    AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
+], KeyTransRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], KeyTransRecipientInfo.prototype, "encryptedKey", void 0);
+
+class KEKIdentifier {
+    constructor(params = {}) {
+        this.keyIdentifier = new OctetString();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: OctetString })
+], KEKIdentifier.prototype, "keyIdentifier", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.GeneralizedTime, optional: true })
+], KEKIdentifier.prototype, "date", void 0);
+__decorate([
+    AsnProp({ type: OtherKeyAttribute, optional: true })
+], KEKIdentifier.prototype, "other", void 0);
+class KEKRecipientInfo {
+    constructor(params = {}) {
+        this.version = CMSVersion.v4;
+        this.kekid = new KEKIdentifier();
+        this.keyEncryptionAlgorithm = new KeyEncryptionAlgorithmIdentifier();
+        this.encryptedKey = new OctetString();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], KEKRecipientInfo.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: KEKIdentifier })
+], KEKRecipientInfo.prototype, "kekid", void 0);
+__decorate([
+    AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
+], KEKRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], KEKRecipientInfo.prototype, "encryptedKey", void 0);
+
+class PasswordRecipientInfo {
+    constructor(params = {}) {
+        this.version = CMSVersion.v0;
+        this.keyEncryptionAlgorithm = new KeyEncryptionAlgorithmIdentifier();
+        this.encryptedKey = new OctetString();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], PasswordRecipientInfo.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: KeyDerivationAlgorithmIdentifier, context: 0, optional: true })
+], PasswordRecipientInfo.prototype, "keyDerivationAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
+], PasswordRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], PasswordRecipientInfo.prototype, "encryptedKey", void 0);
+
+class OtherRecipientInfo {
+    constructor(params = {}) {
+        this.oriType = "";
+        this.oriValue = new ArrayBuffer(0);
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.ObjectIdentifier })
+], OtherRecipientInfo.prototype, "oriType", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Any })
+], OtherRecipientInfo.prototype, "oriValue", void 0);
+let RecipientInfo = class RecipientInfo {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+};
+__decorate([
+    AsnProp({ type: KeyTransRecipientInfo, optional: true })
+], RecipientInfo.prototype, "ktri", void 0);
+__decorate([
+    AsnProp({ type: KeyAgreeRecipientInfo, context: 1, implicit: true, optional: true })
+], RecipientInfo.prototype, "kari", void 0);
+__decorate([
+    AsnProp({ type: KEKRecipientInfo, context: 2, implicit: true, optional: true })
+], RecipientInfo.prototype, "kekri", void 0);
+__decorate([
+    AsnProp({ type: PasswordRecipientInfo, context: 3, implicit: true, optional: true })
+], RecipientInfo.prototype, "pwri", void 0);
+__decorate([
+    AsnProp({ type: OtherRecipientInfo, context: 4, implicit: true, optional: true })
+], RecipientInfo.prototype, "ori", void 0);
+RecipientInfo = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], RecipientInfo);
+
+var RecipientInfos_1;
+let RecipientInfos = RecipientInfos_1 = class RecipientInfos extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, RecipientInfos_1.prototype);
+    }
+};
+RecipientInfos = RecipientInfos_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Set, itemType: RecipientInfo })
+], RecipientInfos);
+
 var RevocationInfoChoices_1;
 class OtherRevocationInfoFormat {
     constructor(params = {}) {
@@ -10931,25 +11310,51 @@ RevocationInfoChoices = RevocationInfoChoices_1 = __decorate([
     AsnType({ type: AsnTypeTypes.Set, itemType: RevocationInfoChoice })
 ], RevocationInfoChoices);
 
-var CMSVersion;
-(function (CMSVersion) {
-    CMSVersion[CMSVersion["v0"] = 0] = "v0";
-    CMSVersion[CMSVersion["v1"] = 1] = "v1";
-    CMSVersion[CMSVersion["v2"] = 2] = "v2";
-    CMSVersion[CMSVersion["v3"] = 3] = "v3";
-    CMSVersion[CMSVersion["v4"] = 4] = "v4";
-    CMSVersion[CMSVersion["v5"] = 5] = "v5";
-})(CMSVersion || (CMSVersion = {}));
-let DigestAlgorithmIdentifier = class DigestAlgorithmIdentifier extends AlgorithmIdentifier {
-};
-DigestAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], DigestAlgorithmIdentifier);
-let SignatureAlgorithmIdentifier = class SignatureAlgorithmIdentifier extends AlgorithmIdentifier {
+class OriginatorInfo {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: CertificateSet, context: 0, implicit: true, optional: true })
+], OriginatorInfo.prototype, "certs", void 0);
+__decorate([
+    AsnProp({ type: RevocationInfoChoices, context: 1, implicit: true, optional: true })
+], OriginatorInfo.prototype, "crls", void 0);
+
+var UnprotectedAttributes_1;
+let UnprotectedAttributes = UnprotectedAttributes_1 = class UnprotectedAttributes extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, UnprotectedAttributes_1.prototype);
+    }
 };
-SignatureAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], SignatureAlgorithmIdentifier);
+UnprotectedAttributes = UnprotectedAttributes_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Set, itemType: Attribute })
+], UnprotectedAttributes);
+class EnvelopedData {
+    constructor(params = {}) {
+        this.version = CMSVersion.v0;
+        this.recipientInfos = new RecipientInfos();
+        this.encryptedContentInfo = new EncryptedContentInfo();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], EnvelopedData.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: OriginatorInfo, context: 0, implicit: true, optional: true })
+], EnvelopedData.prototype, "originatorInfo", void 0);
+__decorate([
+    AsnProp({ type: RecipientInfos })
+], EnvelopedData.prototype, "recipientInfos", void 0);
+__decorate([
+    AsnProp({ type: EncryptedContentInfo })
+], EnvelopedData.prototype, "encryptedContentInfo", void 0);
+__decorate([
+    AsnProp({ type: UnprotectedAttributes, context: 1, implicit: true, optional: true })
+], EnvelopedData.prototype, "unprotectedAttrs", void 0);
 
 let SignerIdentifier = class SignerIdentifier {
     constructor(params = {}) {
@@ -11506,4 +11911,4 @@ __decorate([
     AsnProp({ type: AsnPropTypes.BitString })
 ], CertificationRequest.prototype, "signature", void 0);
 
-export { BasicConstraints as $, AsnData as A, id_DomainNameTechnicalOperator as B, Certificate as C, DomainNameTechnicalOperator as D, Extension as E, id_DomainNameOwner as F, DomainNameOwner as G, id_DomainNameLegalRepresentative as H, InsuranceValue as I, DomainNameLegalRepresentative as J, id_DomainNameBeneficiary as K, DomainNameBeneficiary as L, CertificationRequest as M, Name as N, OIDs as O, Name$1 as P, OtherName as Q, RSAPublicKey as R, DisplayText as S, TypeRelationship as T, UnstructuredName as U, ValuationRanking as V, WebGDPR as W, UserNotice as X, EDIPartyName as Y, AsnIntegerArrayBufferConverter as Z, KeyUsage as _, isX509Pem as a, ExtendedKeyUsage as a0, SubjectKeyIdentifier as a1, AuthorityKeyIdentifier as a2, CRLDistributionPoints as a3, AuthorityInfoAccessSyntax as a4, SubjectInfoAccessSyntax as a5, SubjectAlternativeName as a6, CertificatePolicies as a7, CertificateTransparency as a8, NameConstraints as a9, CertificateTemplate as aa, EnrollCertTypeChoice as ab, CaVersion as ac, QCStatements as ad, NetscapeComment as ae, NetscapeCertType as af, LeiRole as ag, LeiChoice as ah, Timestamp as ai, ArchiveRevInfo as aj, CRLReason as ak, SubjectDirectoryAttributes as al, PrivateKeyUsagePeriod as am, EntrustVersionInfo as an, BiometricSyntax as ao, LogotypeExtn as ap, TNAuthorizationList as aq, PolicyConstraints as ar, PolicyMappings as as, isPkcs10Pem as b, isX509AttributePem as c, certificateRawToBuffer as d, AsnConvert as e, id_ecPublicKey as f, ECParameters as g, id_rsaEncryption as h, isPem as i, hexFormat as j, base64Format as k, getCertificateThumbprint as l, AttributeCertificate as m, Attribute$1 as n, id_pkcs9_at_extensionRequest as o, AsnParser as p, ExtensionRequest as q, id_pkcs9_at_unstructuredName as r, id_pkcs9_at_challengePassword as s, ChallengePassword as t, id_ValuationRanking as u, id_InsuranceValue as v, id_WebGDPR as w, id_ActivityDescription as x, ActivityDescription as y, id_TypeRelationship as z };
+export { AsnIntegerArrayBufferConverter as $, AsnData as A, id_DomainNameTechnicalOperator as B, Certificate as C, DomainNameTechnicalOperator as D, Extension as E, id_DomainNameOwner as F, DomainNameOwner as G, id_DomainNameLegalRepresentative as H, InsuranceValue as I, DomainNameLegalRepresentative as J, id_DomainNameBeneficiary as K, DomainNameBeneficiary as L, AttributeCertificate as M, Name as N, CertificationRequest as O, CertificateList as P, OIDs as Q, RSAPublicKey as R, Name$1 as S, TypeRelationship as T, UnstructuredName as U, ValuationRanking as V, WebGDPR as W, OtherName as X, DisplayText as Y, UserNotice as Z, EDIPartyName as _, isX509Pem as a, KeyUsage as a0, BasicConstraints as a1, ExtendedKeyUsage as a2, SubjectKeyIdentifier as a3, AuthorityKeyIdentifier as a4, CRLDistributionPoints as a5, AuthorityInfoAccessSyntax as a6, SubjectInfoAccessSyntax as a7, SubjectAlternativeName as a8, CertificatePolicies as a9, CertificateTransparency as aa, NameConstraints as ab, CertificateTemplate as ac, EnrollCertTypeChoice as ad, CaVersion as ae, QCStatements as af, NetscapeComment as ag, NetscapeCertType as ah, LeiRole as ai, LeiChoice as aj, Timestamp as ak, ArchiveRevInfo as al, CRLReason as am, SubjectDirectoryAttributes as an, PrivateKeyUsagePeriod as ao, EntrustVersionInfo as ap, BiometricSyntax as aq, LogotypeExtn as ar, TNAuthorizationList as as, PolicyConstraints as at, PolicyMappings as au, CRLNumber as av, IssuingDistributionPoint as aw, isPkcs10Pem as b, isX509AttributePem as c, isX509CRLPem as d, certificateRawToBuffer as e, AsnConvert as f, id_ecPublicKey as g, ECParameters as h, isPem as i, id_rsaEncryption as j, hexFormat as k, base64Format as l, getCertificateThumbprint as m, Attribute$1 as n, id_pkcs9_at_extensionRequest as o, AsnParser as p, ExtensionRequest as q, id_pkcs9_at_unstructuredName as r, id_pkcs9_at_challengePassword as s, ChallengePassword as t, id_ValuationRanking as u, id_InsuranceValue as v, id_WebGDPR as w, id_ActivityDescription as x, ActivityDescription as y, id_TypeRelationship as z };