edockit 0.4.0-dev.0 → 0.4.0-dev.1

package/dist/index.cjs.js

@@ -8,9 +8,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var fflate = require('fflate');
 var x509 = require('@peculiar/x509');
-var certificate = require('./certificate-fc0e06f7.js');
-var identity = require('./identity-1a3dddc3.js');
-var normalize = require('./normalize-60f2d7e6.js');
+var certificate = require('./certificate-c7123a37.js');
+var identity = require('./identity-c9e5052e.js');
+var normalize = require('./normalize-9626be7c.js');
+var asn1Schema = require('@peculiar/asn1-schema');
+var asn1Cms = require('@peculiar/asn1-cms');
+var asn1Tsp = require('@peculiar/asn1-tsp');
+require('@xmldom/xmldom');
+require('xpath');
+require('@peculiar/asn1-ocsp');
+require('@peculiar/asn1-x509');
 
 // Canonicalization method URIs
 const CANONICALIZATION_METHODS = {
@@ -1180,9 +1187,6 @@ const DEFAULT_REVOCATION_OPTIONS = {
     crlTimeout: 10000,
 };
 
-class SubjectKeyIdentifier extends normalize.KeyIdentifier {
-}
-
 // src/core/revocation/crl.ts
 /**
  * OID for CRL Distribution Points extension
@@ -1416,1238 +1420,6 @@ async function checkCertificateRevocation(cert, options = {}) {
     };
 }
 
-class IssuerAndSerialNumber {
-    constructor(params = {}) {
-        this.issuer = new normalize.Name();
-        this.serialNumber = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Name })
-], IssuerAndSerialNumber.prototype, "issuer", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, converter: normalize.AsnIntegerArrayBufferConverter })
-], IssuerAndSerialNumber.prototype, "serialNumber", void 0);
-
-let SignerIdentifier = class SignerIdentifier {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true })
-], SignerIdentifier.prototype, "subjectKeyIdentifier", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerAndSerialNumber })
-], SignerIdentifier.prototype, "issuerAndSerialNumber", void 0);
-SignerIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], SignerIdentifier);
-
-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 normalize.AlgorithmIdentifier {
-};
-DigestAlgorithmIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], DigestAlgorithmIdentifier);
-let SignatureAlgorithmIdentifier = class SignatureAlgorithmIdentifier extends normalize.AlgorithmIdentifier {
-};
-SignatureAlgorithmIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], SignatureAlgorithmIdentifier);
-let KeyEncryptionAlgorithmIdentifier = class KeyEncryptionAlgorithmIdentifier extends normalize.AlgorithmIdentifier {
-};
-KeyEncryptionAlgorithmIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], KeyEncryptionAlgorithmIdentifier);
-let ContentEncryptionAlgorithmIdentifier = class ContentEncryptionAlgorithmIdentifier extends normalize.AlgorithmIdentifier {
-};
-ContentEncryptionAlgorithmIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], ContentEncryptionAlgorithmIdentifier);
-let MessageAuthenticationCodeAlgorithm = class MessageAuthenticationCodeAlgorithm extends normalize.AlgorithmIdentifier {
-};
-MessageAuthenticationCodeAlgorithm = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], MessageAuthenticationCodeAlgorithm);
-let KeyDerivationAlgorithmIdentifier = class KeyDerivationAlgorithmIdentifier extends normalize.AlgorithmIdentifier {
-};
-KeyDerivationAlgorithmIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], KeyDerivationAlgorithmIdentifier);
-
-class Attribute {
-    constructor(params = {}) {
-        this.attrType = "";
-        this.attrValues = [];
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], Attribute.prototype, "attrType", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any, repeated: "set" })
-], Attribute.prototype, "attrValues", void 0);
-
-var SignerInfos_1;
-class SignerInfo {
-    constructor(params = {}) {
-        this.version = CMSVersion.v0;
-        this.sid = new SignerIdentifier();
-        this.digestAlgorithm = new DigestAlgorithmIdentifier();
-        this.signatureAlgorithm = new SignatureAlgorithmIdentifier();
-        this.signature = new normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], SignerInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: SignerIdentifier })
-], SignerInfo.prototype, "sid", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: DigestAlgorithmIdentifier })
-], SignerInfo.prototype, "digestAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({
-        type: Attribute,
-        repeated: "set",
-        context: 0,
-        implicit: true,
-        optional: true,
-        raw: true,
-    })
-], SignerInfo.prototype, "signedAttrs", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: SignatureAlgorithmIdentifier })
-], SignerInfo.prototype, "signatureAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], SignerInfo.prototype, "signature", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: Attribute, repeated: "set", context: 1, implicit: true, optional: true })
-], SignerInfo.prototype, "unsignedAttrs", void 0);
-let SignerInfos = SignerInfos_1 = class SignerInfos extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, SignerInfos_1.prototype);
-    }
-};
-SignerInfos = SignerInfos_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Set, itemType: SignerInfo })
-], SignerInfos);
-
-let CounterSignature = class CounterSignature extends SignerInfo {
-};
-CounterSignature = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], CounterSignature);
-
-let SigningTime = class SigningTime extends normalize.Time {
-};
-SigningTime = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], SigningTime);
-
-class ACClearAttrs {
-    constructor(params = {}) {
-        this.acIssuer = new normalize.GeneralName();
-        this.acSerial = 0;
-        this.attrs = [];
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName })
-], ACClearAttrs.prototype, "acIssuer", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], ACClearAttrs.prototype, "acSerial", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Attribute, repeated: "sequence" })
-], ACClearAttrs.prototype, "attrs", void 0);
-
-var AttrSpec_1;
-let AttrSpec = AttrSpec_1 = class AttrSpec extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, AttrSpec_1.prototype);
-    }
-};
-AttrSpec = AttrSpec_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence, itemType: normalize.AsnPropTypes.ObjectIdentifier })
-], AttrSpec);
-
-class AAControls {
-    constructor(params = {}) {
-        this.permitUnSpecified = true;
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, optional: true })
-], AAControls.prototype, "pathLenConstraint", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: AttrSpec, implicit: true, context: 0, optional: true })
-], AAControls.prototype, "permittedAttrs", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: AttrSpec, implicit: true, context: 1, optional: true })
-], AAControls.prototype, "excludedAttrs", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Boolean, defaultValue: true })
-], AAControls.prototype, "permitUnSpecified", void 0);
-
-class IssuerSerial {
-    constructor(params = {}) {
-        this.issuer = new normalize.GeneralNames();
-        this.serial = new ArrayBuffer(0);
-        this.issuerUID = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralNames })
-], IssuerSerial.prototype, "issuer", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, converter: normalize.AsnIntegerArrayBufferConverter })
-], IssuerSerial.prototype, "serial", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.BitString, optional: true })
-], IssuerSerial.prototype, "issuerUID", void 0);
-
-var DigestedObjectType;
-(function (DigestedObjectType) {
-    DigestedObjectType[DigestedObjectType["publicKey"] = 0] = "publicKey";
-    DigestedObjectType[DigestedObjectType["publicKeyCert"] = 1] = "publicKeyCert";
-    DigestedObjectType[DigestedObjectType["otherObjectTypes"] = 2] = "otherObjectTypes";
-})(DigestedObjectType || (DigestedObjectType = {}));
-class ObjectDigestInfo {
-    constructor(params = {}) {
-        this.digestedObjectType = DigestedObjectType.publicKey;
-        this.digestAlgorithm = new normalize.AlgorithmIdentifier();
-        this.objectDigest = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Enumerated })
-], ObjectDigestInfo.prototype, "digestedObjectType", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier, optional: true })
-], ObjectDigestInfo.prototype, "otherObjectTypeID", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AlgorithmIdentifier })
-], ObjectDigestInfo.prototype, "digestAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.BitString })
-], ObjectDigestInfo.prototype, "objectDigest", void 0);
-
-class V2Form {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralNames, optional: true })
-], V2Form.prototype, "issuerName", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerSerial, context: 0, implicit: true, optional: true })
-], V2Form.prototype, "baseCertificateID", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: ObjectDigestInfo, context: 1, implicit: true, optional: true })
-], V2Form.prototype, "objectDigestInfo", void 0);
-
-let AttCertIssuer = class AttCertIssuer {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName, repeated: "sequence" })
-], AttCertIssuer.prototype, "v1Form", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: V2Form, context: 0, implicit: true })
-], AttCertIssuer.prototype, "v2Form", void 0);
-AttCertIssuer = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], AttCertIssuer);
-
-class AttCertValidityPeriod {
-    constructor(params = {}) {
-        this.notBeforeTime = new Date();
-        this.notAfterTime = new Date();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.GeneralizedTime })
-], AttCertValidityPeriod.prototype, "notBeforeTime", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.GeneralizedTime })
-], AttCertValidityPeriod.prototype, "notAfterTime", void 0);
-
-class Holder {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerSerial, implicit: true, context: 0, optional: true })
-], Holder.prototype, "baseCertificateID", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralNames, implicit: true, context: 1, optional: true })
-], Holder.prototype, "entityName", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: ObjectDigestInfo, implicit: true, context: 2, optional: true })
-], Holder.prototype, "objectDigestInfo", void 0);
-
-var AttCertVersion;
-(function (AttCertVersion) {
-    AttCertVersion[AttCertVersion["v2"] = 1] = "v2";
-})(AttCertVersion || (AttCertVersion = {}));
-class AttributeCertificateInfo {
-    constructor(params = {}) {
-        this.version = AttCertVersion.v2;
-        this.holder = new Holder();
-        this.issuer = new AttCertIssuer();
-        this.signature = new normalize.AlgorithmIdentifier();
-        this.serialNumber = new ArrayBuffer(0);
-        this.attrCertValidityPeriod = new AttCertValidityPeriod();
-        this.attributes = [];
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], AttributeCertificateInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: Holder })
-], AttributeCertificateInfo.prototype, "holder", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: AttCertIssuer })
-], AttributeCertificateInfo.prototype, "issuer", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AlgorithmIdentifier })
-], AttributeCertificateInfo.prototype, "signature", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, converter: normalize.AsnIntegerArrayBufferConverter })
-], AttributeCertificateInfo.prototype, "serialNumber", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: AttCertValidityPeriod })
-], AttributeCertificateInfo.prototype, "attrCertValidityPeriod", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Attribute, repeated: "sequence" })
-], AttributeCertificateInfo.prototype, "attributes", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.BitString, optional: true })
-], AttributeCertificateInfo.prototype, "issuerUniqueID", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Extensions, optional: true })
-], AttributeCertificateInfo.prototype, "extensions", void 0);
-
-class AttributeCertificate {
-    constructor(params = {}) {
-        this.acinfo = new AttributeCertificateInfo();
-        this.signatureAlgorithm = new normalize.AlgorithmIdentifier();
-        this.signatureValue = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: AttributeCertificateInfo })
-], AttributeCertificate.prototype, "acinfo", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AlgorithmIdentifier })
-], AttributeCertificate.prototype, "signatureAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.BitString })
-], AttributeCertificate.prototype, "signatureValue", void 0);
-
-var ClassListFlags;
-(function (ClassListFlags) {
-    ClassListFlags[ClassListFlags["unmarked"] = 1] = "unmarked";
-    ClassListFlags[ClassListFlags["unclassified"] = 2] = "unclassified";
-    ClassListFlags[ClassListFlags["restricted"] = 4] = "restricted";
-    ClassListFlags[ClassListFlags["confidential"] = 8] = "confidential";
-    ClassListFlags[ClassListFlags["secret"] = 16] = "secret";
-    ClassListFlags[ClassListFlags["topSecret"] = 32] = "topSecret";
-})(ClassListFlags || (ClassListFlags = {}));
-class ClassList extends normalize.BitString {
-}
-
-class SecurityCategory {
-    constructor(params = {}) {
-        this.type = "";
-        this.value = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier, implicit: true, context: 0 })
-], SecurityCategory.prototype, "type", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any, implicit: true, context: 1 })
-], SecurityCategory.prototype, "value", void 0);
-
-class Clearance {
-    constructor(params = {}) {
-        this.policyId = "";
-        this.classList = new ClassList(ClassListFlags.unclassified);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], Clearance.prototype, "policyId", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: ClassList, defaultValue: new ClassList(ClassListFlags.unclassified) })
-], Clearance.prototype, "classList", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: SecurityCategory, repeated: "set" })
-], Clearance.prototype, "securityCategories", void 0);
-
-class IetfAttrSyntaxValueChoices {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], IetfAttrSyntaxValueChoices.prototype, "cotets", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], IetfAttrSyntaxValueChoices.prototype, "oid", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Utf8String })
-], IetfAttrSyntaxValueChoices.prototype, "string", void 0);
-class IetfAttrSyntax {
-    constructor(params = {}) {
-        this.values = [];
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralNames, implicit: true, context: 0, optional: true })
-], IetfAttrSyntax.prototype, "policyAuthority", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: IetfAttrSyntaxValueChoices, repeated: "sequence" })
-], IetfAttrSyntax.prototype, "values", void 0);
-
-var Targets_1;
-class TargetCert {
-    constructor(params = {}) {
-        this.targetCertificate = new IssuerSerial();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerSerial })
-], TargetCert.prototype, "targetCertificate", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName, optional: true })
-], TargetCert.prototype, "targetName", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: ObjectDigestInfo, optional: true })
-], TargetCert.prototype, "certDigestInfo", void 0);
-let Target = class Target {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName, context: 0, implicit: true })
-], Target.prototype, "targetName", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName, context: 1, implicit: true })
-], Target.prototype, "targetGroup", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: TargetCert, context: 2, implicit: true })
-], Target.prototype, "targetCert", void 0);
-Target = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], Target);
-let Targets = Targets_1 = class Targets extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, Targets_1.prototype);
-    }
-};
-Targets = Targets_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence, itemType: Target })
-], Targets);
-
-var ProxyInfo_1;
-let ProxyInfo = ProxyInfo_1 = class ProxyInfo extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, ProxyInfo_1.prototype);
-    }
-};
-ProxyInfo = ProxyInfo_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence, itemType: Targets })
-], ProxyInfo);
-
-class RoleSyntax {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralNames, implicit: true, context: 0, optional: true })
-], RoleSyntax.prototype, "roleAuthority", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName, implicit: true, context: 1 })
-], RoleSyntax.prototype, "roleName", void 0);
-
-class SvceAuthInfo {
-    constructor(params = {}) {
-        this.service = new normalize.GeneralName();
-        this.ident = new normalize.GeneralName();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName })
-], SvceAuthInfo.prototype, "service", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName })
-], SvceAuthInfo.prototype, "ident", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString, optional: true })
-], SvceAuthInfo.prototype, "authInfo", void 0);
-
-var CertificateSet_1;
-class OtherCertificateFormat {
-    constructor(params = {}) {
-        this.otherCertFormat = "";
-        this.otherCert = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], OtherCertificateFormat.prototype, "otherCertFormat", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any })
-], OtherCertificateFormat.prototype, "otherCert", void 0);
-let CertificateChoices = class CertificateChoices {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Certificate })
-], CertificateChoices.prototype, "certificate", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: AttributeCertificate, context: 2, implicit: true })
-], CertificateChoices.prototype, "v2AttrCert", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: OtherCertificateFormat, context: 3, implicit: true })
-], CertificateChoices.prototype, "other", void 0);
-CertificateChoices = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], CertificateChoices);
-let CertificateSet = CertificateSet_1 = class CertificateSet extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, CertificateSet_1.prototype);
-    }
-};
-CertificateSet = CertificateSet_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Set, itemType: CertificateChoices })
-], CertificateSet);
-
-class ContentInfo {
-    constructor(params = {}) {
-        this.contentType = "";
-        this.content = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], ContentInfo.prototype, "contentType", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any, context: 0 })
-], ContentInfo.prototype, "content", void 0);
-
-let EncapsulatedContent = class EncapsulatedContent {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], EncapsulatedContent.prototype, "single", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any })
-], EncapsulatedContent.prototype, "any", void 0);
-EncapsulatedContent = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], EncapsulatedContent);
-class EncapsulatedContentInfo {
-    constructor(params = {}) {
-        this.eContentType = "";
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], EncapsulatedContentInfo.prototype, "eContentType", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: EncapsulatedContent, context: 0, optional: true })
-], EncapsulatedContentInfo.prototype, "eContent", void 0);
-
-let EncryptedContent = class EncryptedContent {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString, context: 0, implicit: true, optional: true })
-], EncryptedContent.prototype, "value", void 0);
-normalize.__decorate([
-    normalize.AsnProp({
-        type: normalize.OctetString,
-        converter: normalize.AsnConstructedOctetStringConverter,
-        context: 0,
-        implicit: true,
-        optional: true,
-        repeated: "sequence",
-    })
-], EncryptedContent.prototype, "constructedValue", void 0);
-EncryptedContent = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], EncryptedContent);
-class EncryptedContentInfo {
-    constructor(params = {}) {
-        this.contentType = "";
-        this.contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], EncryptedContentInfo.prototype, "contentType", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: ContentEncryptionAlgorithmIdentifier })
-], EncryptedContentInfo.prototype, "contentEncryptionAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: EncryptedContent, optional: true })
-], EncryptedContentInfo.prototype, "encryptedContent", void 0);
-
-class OtherKeyAttribute {
-    constructor(params = {}) {
-        this.keyAttrId = "";
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], OtherKeyAttribute.prototype, "keyAttrId", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any, optional: true })
-], OtherKeyAttribute.prototype, "keyAttr", void 0);
-
-var RecipientEncryptedKeys_1;
-class RecipientKeyIdentifier {
-    constructor(params = {}) {
-        this.subjectKeyIdentifier = new SubjectKeyIdentifier();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: SubjectKeyIdentifier })
-], RecipientKeyIdentifier.prototype, "subjectKeyIdentifier", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.GeneralizedTime, optional: true })
-], RecipientKeyIdentifier.prototype, "date", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: OtherKeyAttribute, optional: true })
-], RecipientKeyIdentifier.prototype, "other", void 0);
-let KeyAgreeRecipientIdentifier = class KeyAgreeRecipientIdentifier {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: RecipientKeyIdentifier, context: 0, implicit: true, optional: true })
-], KeyAgreeRecipientIdentifier.prototype, "rKeyId", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerAndSerialNumber, optional: true })
-], KeyAgreeRecipientIdentifier.prototype, "issuerAndSerialNumber", void 0);
-KeyAgreeRecipientIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], KeyAgreeRecipientIdentifier);
-class RecipientEncryptedKey {
-    constructor(params = {}) {
-        this.rid = new KeyAgreeRecipientIdentifier();
-        this.encryptedKey = new normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyAgreeRecipientIdentifier })
-], RecipientEncryptedKey.prototype, "rid", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], RecipientEncryptedKey.prototype, "encryptedKey", void 0);
-let RecipientEncryptedKeys = RecipientEncryptedKeys_1 = class RecipientEncryptedKeys extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, RecipientEncryptedKeys_1.prototype);
-    }
-};
-RecipientEncryptedKeys = RecipientEncryptedKeys_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence, itemType: RecipientEncryptedKey })
-], RecipientEncryptedKeys);
-class OriginatorPublicKey {
-    constructor(params = {}) {
-        this.algorithm = new normalize.AlgorithmIdentifier();
-        this.publicKey = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AlgorithmIdentifier })
-], OriginatorPublicKey.prototype, "algorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.BitString })
-], OriginatorPublicKey.prototype, "publicKey", void 0);
-let OriginatorIdentifierOrKey = class OriginatorIdentifierOrKey {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true, optional: true })
-], OriginatorIdentifierOrKey.prototype, "subjectKeyIdentifier", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: OriginatorPublicKey, context: 1, implicit: true, optional: true })
-], OriginatorIdentifierOrKey.prototype, "originatorKey", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerAndSerialNumber, optional: true })
-], OriginatorIdentifierOrKey.prototype, "issuerAndSerialNumber", void 0);
-OriginatorIdentifierOrKey = normalize.__decorate([
-    normalize.AsnType({ type: normalize.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);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], KeyAgreeRecipientInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: OriginatorIdentifierOrKey, context: 0 })
-], KeyAgreeRecipientInfo.prototype, "originator", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString, context: 1, optional: true })
-], KeyAgreeRecipientInfo.prototype, "ukm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
-], KeyAgreeRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: RecipientEncryptedKeys })
-], KeyAgreeRecipientInfo.prototype, "recipientEncryptedKeys", void 0);
-
-let RecipientIdentifier = class RecipientIdentifier {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true })
-], RecipientIdentifier.prototype, "subjectKeyIdentifier", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: IssuerAndSerialNumber })
-], RecipientIdentifier.prototype, "issuerAndSerialNumber", void 0);
-RecipientIdentifier = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], RecipientIdentifier);
-class KeyTransRecipientInfo {
-    constructor(params = {}) {
-        this.version = CMSVersion.v0;
-        this.rid = new RecipientIdentifier();
-        this.keyEncryptionAlgorithm = new KeyEncryptionAlgorithmIdentifier();
-        this.encryptedKey = new normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], KeyTransRecipientInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: RecipientIdentifier })
-], KeyTransRecipientInfo.prototype, "rid", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
-], KeyTransRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], KeyTransRecipientInfo.prototype, "encryptedKey", void 0);
-
-class KEKIdentifier {
-    constructor(params = {}) {
-        this.keyIdentifier = new normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], KEKIdentifier.prototype, "keyIdentifier", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.GeneralizedTime, optional: true })
-], KEKIdentifier.prototype, "date", void 0);
-normalize.__decorate([
-    normalize.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 normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], KEKRecipientInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KEKIdentifier })
-], KEKRecipientInfo.prototype, "kekid", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
-], KEKRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], KEKRecipientInfo.prototype, "encryptedKey", void 0);
-
-class PasswordRecipientInfo {
-    constructor(params = {}) {
-        this.version = CMSVersion.v0;
-        this.keyEncryptionAlgorithm = new KeyEncryptionAlgorithmIdentifier();
-        this.encryptedKey = new normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], PasswordRecipientInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyDerivationAlgorithmIdentifier, context: 0, optional: true })
-], PasswordRecipientInfo.prototype, "keyDerivationAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyEncryptionAlgorithmIdentifier })
-], PasswordRecipientInfo.prototype, "keyEncryptionAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], PasswordRecipientInfo.prototype, "encryptedKey", void 0);
-
-class OtherRecipientInfo {
-    constructor(params = {}) {
-        this.oriType = "";
-        this.oriValue = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], OtherRecipientInfo.prototype, "oriType", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any })
-], OtherRecipientInfo.prototype, "oriValue", void 0);
-let RecipientInfo = class RecipientInfo {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyTransRecipientInfo, optional: true })
-], RecipientInfo.prototype, "ktri", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KeyAgreeRecipientInfo, context: 1, implicit: true, optional: true })
-], RecipientInfo.prototype, "kari", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: KEKRecipientInfo, context: 2, implicit: true, optional: true })
-], RecipientInfo.prototype, "kekri", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: PasswordRecipientInfo, context: 3, implicit: true, optional: true })
-], RecipientInfo.prototype, "pwri", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: OtherRecipientInfo, context: 4, implicit: true, optional: true })
-], RecipientInfo.prototype, "ori", void 0);
-RecipientInfo = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], RecipientInfo);
-
-var RecipientInfos_1;
-let RecipientInfos = RecipientInfos_1 = class RecipientInfos extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, RecipientInfos_1.prototype);
-    }
-};
-RecipientInfos = RecipientInfos_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Set, itemType: RecipientInfo })
-], RecipientInfos);
-
-var RevocationInfoChoices_1;
-class OtherRevocationInfoFormat {
-    constructor(params = {}) {
-        this.otherRevInfoFormat = "";
-        this.otherRevInfo = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], OtherRevocationInfoFormat.prototype, "otherRevInfoFormat", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Any })
-], OtherRevocationInfoFormat.prototype, "otherRevInfo", void 0);
-let RevocationInfoChoice = class RevocationInfoChoice {
-    constructor(params = {}) {
-        this.other = new OtherRevocationInfoFormat();
-        Object.assign(this, params);
-    }
-};
-normalize.__decorate([
-    normalize.AsnProp({ type: OtherRevocationInfoFormat, context: 1, implicit: true })
-], RevocationInfoChoice.prototype, "other", void 0);
-RevocationInfoChoice = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Choice })
-], RevocationInfoChoice);
-let RevocationInfoChoices = RevocationInfoChoices_1 = class RevocationInfoChoices extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, RevocationInfoChoices_1.prototype);
-    }
-};
-RevocationInfoChoices = RevocationInfoChoices_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Set, itemType: RevocationInfoChoice })
-], RevocationInfoChoices);
-
-class OriginatorInfo {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: CertificateSet, context: 0, implicit: true, optional: true })
-], OriginatorInfo.prototype, "certs", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: RevocationInfoChoices, context: 1, implicit: true, optional: true })
-], OriginatorInfo.prototype, "crls", void 0);
-
-var UnprotectedAttributes_1;
-let UnprotectedAttributes = UnprotectedAttributes_1 = class UnprotectedAttributes extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, UnprotectedAttributes_1.prototype);
-    }
-};
-UnprotectedAttributes = UnprotectedAttributes_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.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);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], EnvelopedData.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: OriginatorInfo, context: 0, implicit: true, optional: true })
-], EnvelopedData.prototype, "originatorInfo", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: RecipientInfos })
-], EnvelopedData.prototype, "recipientInfos", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: EncryptedContentInfo })
-], EnvelopedData.prototype, "encryptedContentInfo", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: UnprotectedAttributes, context: 1, implicit: true, optional: true })
-], EnvelopedData.prototype, "unprotectedAttrs", void 0);
-
-var DigestAlgorithmIdentifiers_1;
-let DigestAlgorithmIdentifiers = DigestAlgorithmIdentifiers_1 = class DigestAlgorithmIdentifiers extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, DigestAlgorithmIdentifiers_1.prototype);
-    }
-};
-DigestAlgorithmIdentifiers = DigestAlgorithmIdentifiers_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Set, itemType: DigestAlgorithmIdentifier })
-], DigestAlgorithmIdentifiers);
-class SignedData {
-    constructor(params = {}) {
-        this.version = CMSVersion.v0;
-        this.digestAlgorithms = new DigestAlgorithmIdentifiers();
-        this.encapContentInfo = new EncapsulatedContentInfo();
-        this.signerInfos = new SignerInfos();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], SignedData.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: DigestAlgorithmIdentifiers })
-], SignedData.prototype, "digestAlgorithms", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: EncapsulatedContentInfo })
-], SignedData.prototype, "encapContentInfo", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: CertificateSet, context: 0, implicit: true, optional: true })
-], SignedData.prototype, "certificates", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: RevocationInfoChoices, context: 1, implicit: true, optional: true })
-], SignedData.prototype, "crls", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: SignerInfos })
-], SignedData.prototype, "signerInfos", void 0);
-
-class Accuracy {
-    constructor(params = {}) {
-        this.seconds = 0;
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, optional: true })
-], Accuracy.prototype, "seconds", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, context: 0, implicit: true, optional: true })
-], Accuracy.prototype, "millis", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, context: 1, implicit: true, optional: true })
-], Accuracy.prototype, "micros", void 0);
-
-class MessageImprint {
-    constructor(params = {}) {
-        this.hashAlgorithm = new normalize.AlgorithmIdentifier();
-        this.hashedMessage = new normalize.OctetString();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AlgorithmIdentifier })
-], MessageImprint.prototype, "hashAlgorithm", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.OctetString })
-], MessageImprint.prototype, "hashedMessage", void 0);
-
-var PKIFailureInfoFlags;
-(function (PKIFailureInfoFlags) {
-    PKIFailureInfoFlags[PKIFailureInfoFlags["badAlg"] = 1] = "badAlg";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["badRequest"] = 2] = "badRequest";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["badDataFormat"] = 16] = "badDataFormat";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["timeNotAvailable"] = 8192] = "timeNotAvailable";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["unacceptedPolicy"] = 16384] = "unacceptedPolicy";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["unacceptedExtension"] = 32768] = "unacceptedExtension";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["addInfoNotAvailable"] = 65536] = "addInfoNotAvailable";
-    PKIFailureInfoFlags[PKIFailureInfoFlags["systemFailure"] = 16777216] = "systemFailure";
-})(PKIFailureInfoFlags || (PKIFailureInfoFlags = {}));
-class PKIFailureInfo extends normalize.BitString {
-    toJSON() {
-        const flag = this.toNumber();
-        const res = [];
-        if (flag & PKIFailureInfoFlags.addInfoNotAvailable) {
-            res.push("addInfoNotAvailable");
-        }
-        if (flag & PKIFailureInfoFlags.badAlg) {
-            res.push("badAlg");
-        }
-        if (flag & PKIFailureInfoFlags.badDataFormat) {
-            res.push("badDataFormat");
-        }
-        if (flag & PKIFailureInfoFlags.badRequest) {
-            res.push("badRequest");
-        }
-        if (flag & PKIFailureInfoFlags.systemFailure) {
-            res.push("systemFailure");
-        }
-        if (flag & PKIFailureInfoFlags.systemFailure) {
-            res.push("systemFailure");
-        }
-        if (flag & PKIFailureInfoFlags.timeNotAvailable) {
-            res.push("timeNotAvailable");
-        }
-        if (flag & PKIFailureInfoFlags.unacceptedExtension) {
-            res.push("unacceptedExtension");
-        }
-        if (flag & PKIFailureInfoFlags.unacceptedPolicy) {
-            res.push("unacceptedPolicy");
-        }
-        return res;
-    }
-    toString() {
-        return `[${this.toJSON().join(", ")}]`;
-    }
-}
-
-var PKIStatus;
-(function (PKIStatus) {
-    PKIStatus[PKIStatus["granted"] = 0] = "granted";
-    PKIStatus[PKIStatus["grantedWithMods"] = 1] = "grantedWithMods";
-    PKIStatus[PKIStatus["rejection"] = 2] = "rejection";
-    PKIStatus[PKIStatus["waiting"] = 3] = "waiting";
-    PKIStatus[PKIStatus["revocationWarning"] = 4] = "revocationWarning";
-    PKIStatus[PKIStatus["revocationNotification"] = 5] = "revocationNotification";
-})(PKIStatus || (PKIStatus = {}));
-
-var PKIFreeText_1;
-let PKIFreeText = PKIFreeText_1 = class PKIFreeText extends normalize.AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, PKIFreeText_1.prototype);
-    }
-};
-PKIFreeText = PKIFreeText_1 = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence, itemType: normalize.AsnPropTypes.Utf8String })
-], PKIFreeText);
-class PKIStatusInfo {
-    constructor(params = {}) {
-        this.status = PKIStatus.granted;
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], PKIStatusInfo.prototype, "status", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: PKIFreeText, optional: true })
-], PKIStatusInfo.prototype, "statusString", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: PKIFailureInfo, optional: true })
-], PKIStatusInfo.prototype, "failInfo", void 0);
-
-var TimeStampReqVersion;
-(function (TimeStampReqVersion) {
-    TimeStampReqVersion[TimeStampReqVersion["v1"] = 1] = "v1";
-})(TimeStampReqVersion || (TimeStampReqVersion = {}));
-class TimeStampReq {
-    constructor(params = {}) {
-        this.version = TimeStampReqVersion.v1;
-        this.messageImprint = new MessageImprint();
-        this.certReq = false;
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], TimeStampReq.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: MessageImprint })
-], TimeStampReq.prototype, "messageImprint", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier, optional: true })
-], TimeStampReq.prototype, "reqPolicy", void 0);
-normalize.__decorate([
-    normalize.AsnProp({
-        type: normalize.AsnPropTypes.Integer,
-        converter: normalize.AsnIntegerArrayBufferConverter,
-        optional: true,
-    })
-], TimeStampReq.prototype, "nonce", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Boolean, defaultValue: false })
-], TimeStampReq.prototype, "certReq", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Extensions, optional: true, context: 0, implicit: true })
-], TimeStampReq.prototype, "extensions", void 0);
-
-let TimeStampToken = class TimeStampToken extends ContentInfo {
-};
-TimeStampToken = normalize.__decorate([
-    normalize.AsnType({ type: normalize.AsnTypeTypes.Sequence })
-], TimeStampToken);
-
-class TimeStampResp {
-    constructor(params = {}) {
-        this.status = new PKIStatusInfo();
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: PKIStatusInfo })
-], TimeStampResp.prototype, "status", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: TimeStampToken, optional: true })
-], TimeStampResp.prototype, "timeStampToken", void 0);
-
-var TSTInfoVersion;
-(function (TSTInfoVersion) {
-    TSTInfoVersion[TSTInfoVersion["v1"] = 1] = "v1";
-})(TSTInfoVersion || (TSTInfoVersion = {}));
-class TSTInfo {
-    constructor(params = {}) {
-        this.version = TSTInfoVersion.v1;
-        this.policy = "";
-        this.messageImprint = new MessageImprint();
-        this.serialNumber = new ArrayBuffer(0);
-        this.genTime = new Date();
-        this.ordering = false;
-        Object.assign(this, params);
-    }
-}
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer })
-], TSTInfo.prototype, "version", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.ObjectIdentifier })
-], TSTInfo.prototype, "policy", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: MessageImprint })
-], TSTInfo.prototype, "messageImprint", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Integer, converter: normalize.AsnIntegerArrayBufferConverter })
-], TSTInfo.prototype, "serialNumber", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.GeneralizedTime })
-], TSTInfo.prototype, "genTime", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: Accuracy, optional: true })
-], TSTInfo.prototype, "accuracy", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.AsnPropTypes.Boolean, defaultValue: false })
-], TSTInfo.prototype, "ordering", void 0);
-normalize.__decorate([
-    normalize.AsnProp({
-        type: normalize.AsnPropTypes.Integer,
-        converter: normalize.AsnIntegerArrayBufferConverter,
-        optional: true,
-    })
-], TSTInfo.prototype, "nonce", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.GeneralName, context: 0, optional: true })
-], TSTInfo.prototype, "tsa", void 0);
-normalize.__decorate([
-    normalize.AsnProp({ type: normalize.Extensions, context: 1, implicit: true, optional: true })
-], TSTInfo.prototype, "extensions", void 0);
-
 // src/core/timestamp/verify.ts
 /**
  * OID for SignedData content type
@@ -2710,14 +1482,14 @@ function parseTimestamp(timestampBase64) {
     try {
         const tokenBuffer = normalize.base64ToArrayBuffer(timestampBase64);
         // Parse as ContentInfo (TimeStampToken extends ContentInfo)
-        const contentInfo = identity.AsnConvert.parse(tokenBuffer, ContentInfo);
+        const contentInfo = asn1Schema.AsnConvert.parse(tokenBuffer, asn1Cms.ContentInfo);
         // Verify it's SignedData
         if (contentInfo.contentType !== id_signedData) {
             console.warn("Timestamp is not SignedData");
             return null;
         }
         // Parse SignedData
-        const signedData = identity.AsnConvert.parse(contentInfo.content, SignedData);
+        const signedData = asn1Schema.AsnConvert.parse(contentInfo.content, asn1Cms.SignedData);
         // Verify encapsulated content is TSTInfo
         if (signedData.encapContentInfo.eContentType !== id_ct_TSTInfo) {
             console.warn("SignedData does not contain TSTInfo");
@@ -2740,16 +1512,16 @@ function parseTimestamp(timestampBase64) {
         }
         else {
             // Try to serialize the whole thing if it's already ASN.1 parsed
-            tstInfoBuffer = identity.AsnConvert.serialize(eContent);
+            tstInfoBuffer = asn1Schema.AsnConvert.serialize(eContent);
         }
-        const tstInfo = identity.AsnConvert.parse(tstInfoBuffer, TSTInfo);
+        const tstInfo = asn1Schema.AsnConvert.parse(tstInfoBuffer, asn1Tsp.TSTInfo);
         // Extract TSA certificate if present
         let tsaCertificate;
         if (signedData.certificates && signedData.certificates.length > 0) {
             // Get the first certificate (usually the TSA cert)
             const cert = signedData.certificates[0];
             if ("certificate" in cert && cert.certificate) {
-                tsaCertificate = normalize.arrayBufferToPEM(identity.AsnConvert.serialize(cert.certificate));
+                tsaCertificate = normalize.arrayBufferToPEM(asn1Schema.AsnConvert.serialize(cert.certificate));
             }
         }
         // Extract TSA name if present
@@ -4147,7 +2919,7 @@ async function verifySignature(signatureInfo, files, options = {}) {
     const timestampValid = !signatureInfo.signatureTimestamp ||
         options.verifyTimestamps === false ||
         (timestampResult?.isValid ?? true);
-    const isValid = certResult.isValid && checksumResult.isValid && signatureResult.isValid && timestampValid;
+    let isValid = certResult.isValid && checksumResult.isValid && signatureResult.isValid && timestampValid;
     // Determine validation status and limitations
     let status = "VALID";
     let statusMessage;
@@ -4217,6 +2989,30 @@ async function verifySignature(signatureInfo, files, options = {}) {
             statusMessage = errors[0] || "Verification failed";
         }
     }
+    // If everything else is valid but the issuer is not on the trusted list,
+    // downgrade from VALID to INDETERMINATE — crypto is sound but trust is unconfirmed
+    if (status === "VALID" && options.trustListProvider) {
+        if (trustListMatch && (!trustListMatch.found || trustListMatch.trustedAtTime === false)) {
+            status = "INDETERMINATE";
+            isValid = false;
+            statusMessage = trustListMatch.found
+                ? "Signer issuer found in trusted list but was not trusted at signing time"
+                : "Signer issuer not found in trusted list";
+            limitations.push({
+                code: "ISSUER_NOT_TRUSTED",
+                description: statusMessage,
+            });
+        }
+        else if (!trustListMatch && trustListError) {
+            status = "INDETERMINATE";
+            isValid = false;
+            statusMessage = "Trusted list check failed";
+            limitations.push({
+                code: "TRUST_LIST_CHECK_FAILED",
+                description: trustListError,
+            });
+        }
+    }
     const checklist = options.includeChecklist
         ? buildVerificationChecklist({
             options,