@credo-ts/core 0.6.2-pr-2610-20260107224500 → 0.6.2-pr-2610-20260108113505

package/build/index.d.mts

@@ -92,6 +92,7 @@ import { W3cV2Credential, W3cV2CredentialOptions } from "./modules/vc/models/cre
 import { asArray } from "./utils/array.mjs";
 import { deepEquality, equalsIgnoreOrder, equalsWithOrder } from "./utils/deepEquality.mjs";
 import { indyDidFromPublicKeyBase58, isDid } from "./utils/did.mjs";
+import { IntegrityVerifier } from "./utils/IntegrityVerifier.mjs";
 import { JsonEncoder } from "./utils/JsonEncoder.mjs";
 import { JsonTransformer } from "./utils/JsonTransformer.mjs";
 import { MessageValidator } from "./utils/MessageValidator.mjs";
@@ -271,5 +272,5 @@ declare const utils: {
   addSecondsToDate: typeof addSecondsToDate;
 };
 //#endregion
-export { ANONCREDS_DATA_INTEGRITY_CRYPTOSUITE, Agent, type AgentApi, AgentConfig, AgentContext, AgentContextProvider, type AgentDependencies, AnonCredsDataIntegrityServiceSymbol, AnoncredsDataIntegrityCreatePresentation, AnoncredsDataIntegrityVerifyPresentation, type AnyUint8Array, ApiModule, BaseAgent, BaseEvent, BaseLogger, type BaseName, BaseRecord, BaseRecordAny, type BaseRecordConstructor, Buffer, CREDENTIALS_CONTEXT_V1_URL, CREDENTIALS_CONTEXT_V2_URL, CREDENTIALS_ISSUER_URL, Cache, CacheModule, CacheModuleConfig, CacheModuleOptions, CachedStorageService, type CanBePromise, CertificateSigningRequest, CertificateSigningRequestOptions, ClaimFormat, ClassValidationError, ConsoleLogger, type Constructable, type Constructor, ContentType, CredentialIssuancePurpose, CredentialMultiInstanceState, CredentialMultiInstanceUseMode, type CredentialMultiInstanceUseUpdateMode, CredoError, CredoWebCrypto, CredoWebCryptoKey, CustomDidTags, CustomW3cCredentialTags, DID_V1_CONTEXT_URL, DataIntegrityProof, DataIntegrityProofOptions, DateOnly, DateTransformer, DcqlCredential, DcqlCredentialsForRequest, DcqlEncodedPresentations, DcqlEncodedPresentationsEntry, DcqlError, DcqlFailedCredential, DcqlJwtVpPresentationToCreate, DcqlJwtW3cVpPresentationToCreate, DcqlLdpVpPresentationToCreate, DcqlMatchWithRecord, DcqlMdocCredential, DcqlMdocPresentationToCreate, DcqlModule, DcqlPresentation, DcqlPresentationResult, DcqlPresentationsToCreate, DcqlQuery, DcqlQueryResult, DcqlSdJwtVcCredential, DcqlSdJwtVcPresentationToCreate, DcqlSdJwtW3cVpPresentationToCreate, DcqlSelectCredentialsForRequestOptions, DcqlService, DcqlValidCredential, DcqlW3cVcCredential, DefaultAgentContextProvider, type DefaultAgentModules, DefaultMdocRecordTags, DefaultSdJwtVcRecordTags, DefaultW3cCredentialTags, DefaultW3cV2CredentialTags, DependencyManager, DidCommV1Service, LegacyDidCommV2Service as DidCommV2Service, LegacyDidCommV2ServiceOptions as DidCommV2ServiceOptions, DidCreateOptions, DidCreateResult, DidDeactivateOptions, DidDeactivateResult, DidDocument, DidDocumentBuilder, DidDocumentKey, DidDocumentMetadata, DidDocumentOperation, DidDocumentRole, DidDocumentService, DidJwk, DidKey, DidOperationStateActionBase, DidOperationStateFailed, DidOperationStateFinished, DidOperationStateWait, DidPurpose, DidRecord, DidRecordMetadataKeys, DidRecordProps, DidRegistrar, DidRegistrarService, DidRegistrationExtraOptions, DidRegistrationMetadata, DidRegistrationSecretOptions, DidRepository, DidResolutionMetadata, DidResolutionOptions, DidResolutionResult, DidResolver, DidResolverService, DidUpdateOptions, DidUpdateResult, DidsApi, DidsModule, DidsModuleConfig, DidsModuleConfigOptions, DifPexCredentialsForRequest, DifPexCredentialsForRequestRequirement, DifPexCredentialsForRequestSubmissionEntry, DifPexInputDescriptorToCredentials, DifPexPresentationWithDescriptor, DifPresentationExchangeDefinition, DifPresentationExchangeDefinitionV1, DifPresentationExchangeDefinitionV2, DifPresentationExchangeError, DifPresentationExchangeModule, DifPresentationExchangeService, DifPresentationExchangeSubmission, PresentationSubmissionLocation as DifPresentationExchangeSubmissionLocation, DocumentLoader, type DownloadToFileOptions, ENVELOPED_VERIFIABLE_CREDENTIAL_TYPE, ENVELOPED_VERIFIABLE_PRESENTATION_TYPE, EXPANDED_TYPE_CREDENTIALS_CONTEXT_V1_VC_TYPE, Ed25519Signature2018, Ed25519Signature2020, type EmptyModuleMap, EncodedX509Certificate, EventEmitter, EventMetadata, type FileSystem, GenericRecord, GenericRecordStorageProps, GenericRecordTags, GenericRecordsApi, GenericRecordsModule, HashName, Hasher, IAnonCredsDataIntegrityService, IDisclosureFrame, IPresentationFrame, ImportDidOptions, InMemoryLruCache, InMemoryLruCacheOptions, IndyAgentService, type InitConfig, InjectionSymbols, InjectionToken, IsEnvelopedVerifiableCredentialType, IsEnvelopedVerifiablePresentationType, IsStringOrInstance, IsStringOrInstanceOrArrayOfInstances, IsStringOrStringArray, IsStringOrVerificationMethod, IsUri, IsW3cCredentialSubject, IsW3cIssuer, IsW3cV2Issuer, type JsonArray, JsonEncoder, type JsonObject, JsonTransformer, type JsonValue, JwkDidCreateOptions, JwkDidDeactivateOptions, JwkDidRegistrar, JwkDidResolver, JwkDidUpdateOptions, JwsDetachedFormat, JwsFlattenedDetachedFormat, JwsGeneralFormat, JwsLinkedDataSignature, JwsLinkedDataSignatureOptions, JwsProtectedHeaderOptions, JwsService, JwsSigner, JwsSignerDid, JwsSignerJwk, JwsSignerWithJwk, JwsSignerX5c, Jwt, JwtPayload, JwtPayloadJson, JwtPayloadOptions, KeyDidCreateOptions, KeyDidDeactivateOptions, KeyDidRegistrar, KeyDidResolver, KeyDidUpdateOptions, KeyGenAlgorithm, KeySignParams, index_d_exports as Kms, LdKeyPair, LdKeyPairOptions, LogLevel, Logger, Mdoc, MdocApi, MdocDeviceResponse, MdocDeviceResponseOptions, MdocDeviceResponsePresentationDefinitionOptions, MdocDeviceResponseVerifyOptions, MdocDocumentRequest, MdocError, MdocModule, MdocNameSpaces, MdocOpenId4VpDcApiDraft24SessionTranscriptOptions, MdocOpenId4VpDcApiSessionTranscriptOptions, MdocOpenId4VpDraft18SessionTranscriptOptions, MdocOpenId4VpSessionTranscriptOptions, MdocRecord, MdocRecordInstances, MdocRecordStorageProps, MdocRepository, MdocService, MdocSessionTranscriptByteOptions, MdocSessionTranscriptOptions, MdocSignOptions, MdocStoreOptions, MdocSupportedSignatureAlgorithm, MdocVerifyOptions, MessageValidator, Metadata, type MetadataBase, Module, type ModulesMap, MultiBaseEncoder, MultiHashEncoder, DidCommV2Service as NewDidCommV2Service, DidCommV2ServiceEndpoint as NewDidCommV2ServiceEndpoint, DidCommV2ServiceEndpointOptions as NewDidCommV2ServiceEndpointOptions, type NonEmptyArray, type Optional, ParsedDid, PeerDidCreateOptions, PeerDidDeactivateOptions, PeerDidNumAlgo, PeerDidNumAlgo0CreateOptions, PeerDidNumAlgo1CreateOptions, PeerDidNumAlgo2CreateOptions, PeerDidNumAlgo4CreateOptions, PeerDidRegistrar, PeerDidResolver, PeerDidUpdateOptions, Proof, ProofPurpose, type Query, type QueryOptions, RecordDeletedEvent, RecordDuplicateError, RecordNotFoundError, RecordSavedEvent, RecordTags, RecordUpdatedEvent, Repository, RepositoryEventTypes, type ResolvedDidCommService, SECURITY_CONTEXT_SECP256k1_URL, SECURITY_CONTEXT_URL, SECURITY_CONTEXT_V1_URL, SECURITY_CONTEXT_V2_URL, SECURITY_CONTEXT_V3_URL, SECURITY_JWS_CONTEXT_URL, SECURITY_PROOF_URL, SECURITY_SIGNATURE_URL, SECURITY_X25519_CONTEXT_URL, SaveGenericRecordOption, SdJwtVc, SdJwtVcApi, SdJwtVcError, SdJwtVcHeader, SdJwtVcHolderBinding, SdJwtVcHolderDidBinding, SdJwtVcHolderJwkBinding, SdJwtVcIssuer, SdJwtVcIssuerDid, SdJwtVcIssuerX5c, SdJwtVcModule, SdJwtVcPayload, SdJwtVcPresentOptions, SdJwtVcRecord, SdJwtVcRecordInstances, SdJwtVcRecordStorageProps, SdJwtVcRepository, SdJwtVcService, SdJwtVcSignOptions, SdJwtVcStoreOptions, SdJwtVcTypeMetadata, SdJwtVcTypeMetadataClaim, SdJwtVcTypeMetadataDisplay, SdJwtVcTypeMetadataRenderingMethodSimple, SdJwtVcTypeMetadataRenderingMethodSvgTemplate, SdJwtVcVerifyOptions, ServiceTransformer, Sha1, Sha256, Sha384, Sha512, SignatureSuiteRegistry, SignatureSuiteToken, type SimpleQuery, SingleContextLruCacheItem, SingleContextLruCacheRecord, SingleContextStorageLruCache, SingleContextStorageLruCacheOptions, type SingleOrArray, SingleValidationResult, type StorageService, StorageUpdateService, StorageVersionRecord, StorageVersionRecordProps, StorageVersionRepository, SubmissionEntryCredential, SuiteInfo, TagValue, Tags, TagsBase, TypedArrayEncoder, type Uint8ArrayBuffer, type UnionToIntersection, Update, UpdateAssistant, UpdateAssistantUpdateOptions, type UpdateConfig, type UseInstanceFromCredentialRecordOptions, type UseInstanceFromCredentialRecordReturn, type V0_1ToV0_2UpdateConfig, VERIFIABLE_CREDENTIAL_TYPE, VERIFIABLE_PRESENTATION_TYPE, VERIFICATION_METHOD_TYPE_ECDSA_SECP256K1_VERIFICATION_KEY_2019, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020, VERIFICATION_METHOD_TYPE_JSON_WEB_KEY_2020, VERIFICATION_METHOD_TYPE_MULTIKEY, VERIFICATION_METHOD_TYPE_X25519_KEY_AGREEMENT_KEY_2019, VerifiableCredential, VerifiablePresentation, VerificationMethod, VerificationMethodTransformer, VerificationResult, type VersionString, W3cCreatePresentationOptions, W3cCredential, W3cCredentialOptions, W3cCredentialRecord, W3cCredentialRecordInstances, W3cCredentialRecordOptions, W3cCredentialRepository, W3cCredentialSchema, W3cCredentialSchemaOptions, W3cCredentialService, W3cCredentialStatus, W3cCredentialStatusOptions, W3cCredentialSubject, W3cCredentialSubjectOptions, W3cCredentialSubjectTransformer, W3cCredentialsApi, W3cCredentialsModule, W3cCredentialsModuleConfig, W3cCredentialsModuleConfigOptions, W3cIssuer, W3cIssuerOptions, W3cIssuerTransformer, W3cJsonCredential, W3cJsonLdCredentialService, W3cJsonLdDeriveProofOptions, W3cJsonLdSignCredentialOptions, W3cJsonLdSignPresentationOptions, W3cJsonLdVerifiableCredential, W3cJsonLdVerifiableCredentialOptions, W3cJsonLdVerifiablePresentation, W3cJsonLdVerifiablePresentationOptions, W3cJsonLdVerifyCredentialOptions, W3cJsonLdVerifyPresentationOptions, W3cJsonPresentation, W3cJwtCredentialService, W3cJwtSignCredentialOptions, W3cJwtSignPresentationOptions, W3cJwtVerifiableCredential, W3cJwtVerifiableCredentialOptions, W3cJwtVerifiablePresentation, W3cJwtVerifiablePresentationOptions, W3cJwtVerifyCredentialOptions, W3cJwtVerifyPresentationOptions, W3cPresentation, W3cPresentationOptions, W3cSignCredentialOptions, W3cSignPresentationOptions, W3cStoreCredentialOptions, W3cV2Credential, W3cV2CredentialOptions, W3cV2CredentialRecord, W3cV2CredentialRecordInstances, W3cV2CredentialRecordOptions, W3cV2CredentialRepository, W3cV2CredentialSchema, W3cV2CredentialSchemaOptions, W3cV2CredentialService, W3cV2CredentialStatus, W3cV2CredentialStatusOptions, W3cV2CredentialSubject, W3cV2CredentialSubjectOptions, W3cV2CredentialsApi, W3cV2CredentialsModule, W3cV2EnvelopedVerifiableCredential, W3cV2EnvelopedVerifiableCredentialOptions, W3cV2EnvelopedVerifiableCredentialTransformer, W3cV2EnvelopedVerifiablePresentation, W3cV2EnvelopedVerifiablePresentationOptions, W3cV2Evidence, W3cV2EvidenceOptions, W3cV2Issuer, W3cV2IssuerOptions, W3cV2IssuerTransformer, W3cV2JsonCredential, W3cV2JsonLocalizedValue, W3cV2JsonPresentation, W3cV2JwtCredentialService, W3cV2JwtSignCredentialOptions, W3cV2JwtSignPresentationOptions, W3cV2JwtVerifiableCredential, W3cV2JwtVerifiableCredentialOptions, W3cV2JwtVerifiablePresentation, W3cV2JwtVerifiablePresentationOptions, W3cV2JwtVerifyCredentialOptions, W3cV2JwtVerifyPresentationOptions, W3cV2LocalizedValue, W3cV2LocalizedValueOptions, W3cV2LocalizedValueTransformer, W3cV2Presentation, W3cV2PresentationOptions, W3cV2RefreshService, W3cV2RefreshServiceOptions, W3cV2SdJwt, W3cV2SdJwtCredentialService, W3cV2SdJwtHeader, W3cV2SdJwtPayload, W3cV2SdJwtSignCredentialOptions, W3cV2SdJwtSignPresentationOptions, W3cV2SdJwtVcPresentOptions, W3cV2SdJwtVerifiableCredential, W3cV2SdJwtVerifiableCredentialOptions, W3cV2SdJwtVerifiablePresentation, W3cV2SdJwtVerifiablePresentationOptions, W3cV2SdJwtVerifyCredentialOptions, W3cV2SdJwtVerifyPresentationOptions, W3cV2SignCredentialOptions, W3cV2SignPresentationOptions, W3cV2StoreCredentialOptions, W3cV2TermsOfUse, W3cV2TermsOfUseOptions, W3cV2VerifiableCredential, W3cV2VerifiableCredentialOptions, W3cV2VerifiableCredentialTransformer, W3cV2VerifyCredentialOptions, W3cV2VerifyCredentialResult, W3cV2VerifyPresentationOptions, W3cV2VerifyPresentationResult, W3cVerifiableCredential, W3cVerifiableCredentialTransformer, W3cVerifiablePresentation, W3cVerifyCredentialOptions, W3cVerifyCredentialResult, W3cVerifyPresentationOptions, W3cVerifyPresentationResult, WebDidResolver, X509Api, X509Certificate, X509CertificateExtensionsOptions, X509CertificateIssuerAndSubjectOptions, X509CertificateOptions, X509CertificateSigningRequestExtensionsOptions, X509CreateCertificateChainOptions, X509CreateCertificateOptions, X509CreateCertificateSigningRequestOptions, X509Error, X509ExtendedKeyUsage, X509GetLeafCertificateOptions, X509KeyUsage, X509Module, X509ModuleConfig, X509ModuleConfigOptions, X509ParseCertificateOptions, X509ParseCertificateSigningRequestOptions, X509Service, X509ValidateCertificateChainOptions, X509VerificationContext, X509VerificationTypeCredential, X509VerificationTypeOauth2ClientAttestation, X509VerificationTypeOauth2SecuredAuthorizationRequest, X509VerificationTypeOpenId4VciCredentialIssuerMetadata, X509VerificationTypeOpenId4VciKeyAttestation, type XOR, ZodValidationError, asArray, base64ToBase64URL, canUseInstanceFromCredentialRecord, convertName, convertPublicKeyToX25519, createAuthorityKeyIdentifierExtension, createBasicConstraintsExtension, createCrlDistributionPointsExtension, createExtendedKeyUsagesExtension, createIssuerAlternativeNameExtension, createKeyUsagesExtension, createPeerDidDocumentFromServices, createSubjectAlternativeNameExtension, createSubjectKeyIdentifierExtension, dcqlGetPresentationsToCreate, decodeSdJwt, deepEquality, deriveProof, didDocumentJsonToNumAlgo1Did, didDocumentToNumAlgo2Did, didDocumentToNumAlgo4Did, didKeyToEd25519PublicJwk, didKeyToVerkey, equalsIgnoreOrder, equalsWithOrder, extractPresentationsWithDescriptorsFromSubmission, extractX509CertificatesFromJwt, filterContextCorrelationId, findMatchingEd25519Key, findVerificationMethodByKeyType, getAlternativeDidsForPeerDid, getApiForModuleByName, getDirFromFilePath, getDomainFromUrl, getEcdsaSecp256k1VerificationKey2019, getEd25519VerificationKey2018, getEd25519VerificationKey2020, getJsonWebKey2020, getKmsKeyIdForVerifiacationMethod, getMultikey, getNumAlgoFromPeerDid, getPublicJwkFromEcdsaSecp256k1VerificationKey2019, getPublicJwkFromEd25519VerificationKey2018, getPublicJwkFromEd25519VerificationKey2020, getPublicJwkFromJsonWebKey2020, getPublicJwkFromMultikey, getPublicJwkFromVerificationMethod, getPublicJwkFrommX25519KeyAgreementKey2019, getRegisteredModuleByInstance, getRegisteredModuleByName, getX25519KeyAgreementKey2019, inject, injectAll, injectable, isDid, isDidKey, isEcdsaSecp256k1VerificationKey2019, isEd25519VerificationKey2018, isEd25519VerificationKey2020, isJsonObject, isJsonWebKey2020, isMdocSupportedSignatureAlgorithm, isMultikey, isNonEmptyArray, isStorageUpToDate, isValidPeerDid, isX25519KeyAgreementKey2019, joinUriParts, jwaAlgorithmToKeySignParams, keyDidEd25519, keyDidX25519, keyParamsToJwaAlgorithm, mapNonEmptyArray, parseDid, publicJwkToCryptoKeyAlgorithm, replaceError, sdJwtVcHasher, serviceTypes, tryParseDid, useInstanceFromCredentialRecord, utils, vcLibraries, verkeyToDidKey, verkeyToPublicJwk, w3cDate };
+export { ANONCREDS_DATA_INTEGRITY_CRYPTOSUITE, Agent, type AgentApi, AgentConfig, AgentContext, AgentContextProvider, type AgentDependencies, AnonCredsDataIntegrityServiceSymbol, AnoncredsDataIntegrityCreatePresentation, AnoncredsDataIntegrityVerifyPresentation, type AnyUint8Array, ApiModule, BaseAgent, BaseEvent, BaseLogger, type BaseName, BaseRecord, BaseRecordAny, type BaseRecordConstructor, Buffer, CREDENTIALS_CONTEXT_V1_URL, CREDENTIALS_CONTEXT_V2_URL, CREDENTIALS_ISSUER_URL, Cache, CacheModule, CacheModuleConfig, CacheModuleOptions, CachedStorageService, type CanBePromise, CertificateSigningRequest, CertificateSigningRequestOptions, ClaimFormat, ClassValidationError, ConsoleLogger, type Constructable, type Constructor, ContentType, CredentialIssuancePurpose, CredentialMultiInstanceState, CredentialMultiInstanceUseMode, type CredentialMultiInstanceUseUpdateMode, CredoError, CredoWebCrypto, CredoWebCryptoKey, CustomDidTags, CustomW3cCredentialTags, DID_V1_CONTEXT_URL, DataIntegrityProof, DataIntegrityProofOptions, DateOnly, DateTransformer, DcqlCredential, DcqlCredentialsForRequest, DcqlEncodedPresentations, DcqlEncodedPresentationsEntry, DcqlError, DcqlFailedCredential, DcqlJwtVpPresentationToCreate, DcqlJwtW3cVpPresentationToCreate, DcqlLdpVpPresentationToCreate, DcqlMatchWithRecord, DcqlMdocCredential, DcqlMdocPresentationToCreate, DcqlModule, DcqlPresentation, DcqlPresentationResult, DcqlPresentationsToCreate, DcqlQuery, DcqlQueryResult, DcqlSdJwtVcCredential, DcqlSdJwtVcPresentationToCreate, DcqlSdJwtW3cVpPresentationToCreate, DcqlSelectCredentialsForRequestOptions, DcqlService, DcqlValidCredential, DcqlW3cVcCredential, DefaultAgentContextProvider, type DefaultAgentModules, DefaultMdocRecordTags, DefaultSdJwtVcRecordTags, DefaultW3cCredentialTags, DefaultW3cV2CredentialTags, DependencyManager, DidCommV1Service, LegacyDidCommV2Service as DidCommV2Service, LegacyDidCommV2ServiceOptions as DidCommV2ServiceOptions, DidCreateOptions, DidCreateResult, DidDeactivateOptions, DidDeactivateResult, DidDocument, DidDocumentBuilder, DidDocumentKey, DidDocumentMetadata, DidDocumentOperation, DidDocumentRole, DidDocumentService, DidJwk, DidKey, DidOperationStateActionBase, DidOperationStateFailed, DidOperationStateFinished, DidOperationStateWait, DidPurpose, DidRecord, DidRecordMetadataKeys, DidRecordProps, DidRegistrar, DidRegistrarService, DidRegistrationExtraOptions, DidRegistrationMetadata, DidRegistrationSecretOptions, DidRepository, DidResolutionMetadata, DidResolutionOptions, DidResolutionResult, DidResolver, DidResolverService, DidUpdateOptions, DidUpdateResult, DidsApi, DidsModule, DidsModuleConfig, DidsModuleConfigOptions, DifPexCredentialsForRequest, DifPexCredentialsForRequestRequirement, DifPexCredentialsForRequestSubmissionEntry, DifPexInputDescriptorToCredentials, DifPexPresentationWithDescriptor, DifPresentationExchangeDefinition, DifPresentationExchangeDefinitionV1, DifPresentationExchangeDefinitionV2, DifPresentationExchangeError, DifPresentationExchangeModule, DifPresentationExchangeService, DifPresentationExchangeSubmission, PresentationSubmissionLocation as DifPresentationExchangeSubmissionLocation, DocumentLoader, type DownloadToFileOptions, ENVELOPED_VERIFIABLE_CREDENTIAL_TYPE, ENVELOPED_VERIFIABLE_PRESENTATION_TYPE, EXPANDED_TYPE_CREDENTIALS_CONTEXT_V1_VC_TYPE, Ed25519Signature2018, Ed25519Signature2020, type EmptyModuleMap, EncodedX509Certificate, EventEmitter, EventMetadata, type FileSystem, GenericRecord, GenericRecordStorageProps, GenericRecordTags, GenericRecordsApi, GenericRecordsModule, HashName, Hasher, IAnonCredsDataIntegrityService, IDisclosureFrame, IPresentationFrame, ImportDidOptions, InMemoryLruCache, InMemoryLruCacheOptions, IndyAgentService, type InitConfig, InjectionSymbols, InjectionToken, IntegrityVerifier, IsEnvelopedVerifiableCredentialType, IsEnvelopedVerifiablePresentationType, IsStringOrInstance, IsStringOrInstanceOrArrayOfInstances, IsStringOrStringArray, IsStringOrVerificationMethod, IsUri, IsW3cCredentialSubject, IsW3cIssuer, IsW3cV2Issuer, type JsonArray, JsonEncoder, type JsonObject, JsonTransformer, type JsonValue, JwkDidCreateOptions, JwkDidDeactivateOptions, JwkDidRegistrar, JwkDidResolver, JwkDidUpdateOptions, JwsDetachedFormat, JwsFlattenedDetachedFormat, JwsGeneralFormat, JwsLinkedDataSignature, JwsLinkedDataSignatureOptions, JwsProtectedHeaderOptions, JwsService, JwsSigner, JwsSignerDid, JwsSignerJwk, JwsSignerWithJwk, JwsSignerX5c, Jwt, JwtPayload, JwtPayloadJson, JwtPayloadOptions, KeyDidCreateOptions, KeyDidDeactivateOptions, KeyDidRegistrar, KeyDidResolver, KeyDidUpdateOptions, KeyGenAlgorithm, KeySignParams, index_d_exports as Kms, LdKeyPair, LdKeyPairOptions, LogLevel, Logger, Mdoc, MdocApi, MdocDeviceResponse, MdocDeviceResponseOptions, MdocDeviceResponsePresentationDefinitionOptions, MdocDeviceResponseVerifyOptions, MdocDocumentRequest, MdocError, MdocModule, MdocNameSpaces, MdocOpenId4VpDcApiDraft24SessionTranscriptOptions, MdocOpenId4VpDcApiSessionTranscriptOptions, MdocOpenId4VpDraft18SessionTranscriptOptions, MdocOpenId4VpSessionTranscriptOptions, MdocRecord, MdocRecordInstances, MdocRecordStorageProps, MdocRepository, MdocService, MdocSessionTranscriptByteOptions, MdocSessionTranscriptOptions, MdocSignOptions, MdocStoreOptions, MdocSupportedSignatureAlgorithm, MdocVerifyOptions, MessageValidator, Metadata, type MetadataBase, Module, type ModulesMap, MultiBaseEncoder, MultiHashEncoder, DidCommV2Service as NewDidCommV2Service, DidCommV2ServiceEndpoint as NewDidCommV2ServiceEndpoint, DidCommV2ServiceEndpointOptions as NewDidCommV2ServiceEndpointOptions, type NonEmptyArray, type Optional, ParsedDid, PeerDidCreateOptions, PeerDidDeactivateOptions, PeerDidNumAlgo, PeerDidNumAlgo0CreateOptions, PeerDidNumAlgo1CreateOptions, PeerDidNumAlgo2CreateOptions, PeerDidNumAlgo4CreateOptions, PeerDidRegistrar, PeerDidResolver, PeerDidUpdateOptions, Proof, ProofPurpose, type Query, type QueryOptions, RecordDeletedEvent, RecordDuplicateError, RecordNotFoundError, RecordSavedEvent, RecordTags, RecordUpdatedEvent, Repository, RepositoryEventTypes, type ResolvedDidCommService, SECURITY_CONTEXT_SECP256k1_URL, SECURITY_CONTEXT_URL, SECURITY_CONTEXT_V1_URL, SECURITY_CONTEXT_V2_URL, SECURITY_CONTEXT_V3_URL, SECURITY_JWS_CONTEXT_URL, SECURITY_PROOF_URL, SECURITY_SIGNATURE_URL, SECURITY_X25519_CONTEXT_URL, SaveGenericRecordOption, SdJwtVc, SdJwtVcApi, SdJwtVcError, SdJwtVcHeader, SdJwtVcHolderBinding, SdJwtVcHolderDidBinding, SdJwtVcHolderJwkBinding, SdJwtVcIssuer, SdJwtVcIssuerDid, SdJwtVcIssuerX5c, SdJwtVcModule, SdJwtVcPayload, SdJwtVcPresentOptions, SdJwtVcRecord, SdJwtVcRecordInstances, SdJwtVcRecordStorageProps, SdJwtVcRepository, SdJwtVcService, SdJwtVcSignOptions, SdJwtVcStoreOptions, SdJwtVcTypeMetadata, SdJwtVcTypeMetadataClaim, SdJwtVcTypeMetadataDisplay, SdJwtVcTypeMetadataRenderingMethodSimple, SdJwtVcTypeMetadataRenderingMethodSvgTemplate, SdJwtVcVerifyOptions, ServiceTransformer, Sha1, Sha256, Sha384, Sha512, SignatureSuiteRegistry, SignatureSuiteToken, type SimpleQuery, SingleContextLruCacheItem, SingleContextLruCacheRecord, SingleContextStorageLruCache, SingleContextStorageLruCacheOptions, type SingleOrArray, SingleValidationResult, type StorageService, StorageUpdateService, StorageVersionRecord, StorageVersionRecordProps, StorageVersionRepository, SubmissionEntryCredential, SuiteInfo, TagValue, Tags, TagsBase, TypedArrayEncoder, type Uint8ArrayBuffer, type UnionToIntersection, Update, UpdateAssistant, UpdateAssistantUpdateOptions, type UpdateConfig, type UseInstanceFromCredentialRecordOptions, type UseInstanceFromCredentialRecordReturn, type V0_1ToV0_2UpdateConfig, VERIFIABLE_CREDENTIAL_TYPE, VERIFIABLE_PRESENTATION_TYPE, VERIFICATION_METHOD_TYPE_ECDSA_SECP256K1_VERIFICATION_KEY_2019, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020, VERIFICATION_METHOD_TYPE_JSON_WEB_KEY_2020, VERIFICATION_METHOD_TYPE_MULTIKEY, VERIFICATION_METHOD_TYPE_X25519_KEY_AGREEMENT_KEY_2019, VerifiableCredential, VerifiablePresentation, VerificationMethod, VerificationMethodTransformer, VerificationResult, type VersionString, W3cCreatePresentationOptions, W3cCredential, W3cCredentialOptions, W3cCredentialRecord, W3cCredentialRecordInstances, W3cCredentialRecordOptions, W3cCredentialRepository, W3cCredentialSchema, W3cCredentialSchemaOptions, W3cCredentialService, W3cCredentialStatus, W3cCredentialStatusOptions, W3cCredentialSubject, W3cCredentialSubjectOptions, W3cCredentialSubjectTransformer, W3cCredentialsApi, W3cCredentialsModule, W3cCredentialsModuleConfig, W3cCredentialsModuleConfigOptions, W3cIssuer, W3cIssuerOptions, W3cIssuerTransformer, W3cJsonCredential, W3cJsonLdCredentialService, W3cJsonLdDeriveProofOptions, W3cJsonLdSignCredentialOptions, W3cJsonLdSignPresentationOptions, W3cJsonLdVerifiableCredential, W3cJsonLdVerifiableCredentialOptions, W3cJsonLdVerifiablePresentation, W3cJsonLdVerifiablePresentationOptions, W3cJsonLdVerifyCredentialOptions, W3cJsonLdVerifyPresentationOptions, W3cJsonPresentation, W3cJwtCredentialService, W3cJwtSignCredentialOptions, W3cJwtSignPresentationOptions, W3cJwtVerifiableCredential, W3cJwtVerifiableCredentialOptions, W3cJwtVerifiablePresentation, W3cJwtVerifiablePresentationOptions, W3cJwtVerifyCredentialOptions, W3cJwtVerifyPresentationOptions, W3cPresentation, W3cPresentationOptions, W3cSignCredentialOptions, W3cSignPresentationOptions, W3cStoreCredentialOptions, W3cV2Credential, W3cV2CredentialOptions, W3cV2CredentialRecord, W3cV2CredentialRecordInstances, W3cV2CredentialRecordOptions, W3cV2CredentialRepository, W3cV2CredentialSchema, W3cV2CredentialSchemaOptions, W3cV2CredentialService, W3cV2CredentialStatus, W3cV2CredentialStatusOptions, W3cV2CredentialSubject, W3cV2CredentialSubjectOptions, W3cV2CredentialsApi, W3cV2CredentialsModule, W3cV2EnvelopedVerifiableCredential, W3cV2EnvelopedVerifiableCredentialOptions, W3cV2EnvelopedVerifiableCredentialTransformer, W3cV2EnvelopedVerifiablePresentation, W3cV2EnvelopedVerifiablePresentationOptions, W3cV2Evidence, W3cV2EvidenceOptions, W3cV2Issuer, W3cV2IssuerOptions, W3cV2IssuerTransformer, W3cV2JsonCredential, W3cV2JsonLocalizedValue, W3cV2JsonPresentation, W3cV2JwtCredentialService, W3cV2JwtSignCredentialOptions, W3cV2JwtSignPresentationOptions, W3cV2JwtVerifiableCredential, W3cV2JwtVerifiableCredentialOptions, W3cV2JwtVerifiablePresentation, W3cV2JwtVerifiablePresentationOptions, W3cV2JwtVerifyCredentialOptions, W3cV2JwtVerifyPresentationOptions, W3cV2LocalizedValue, W3cV2LocalizedValueOptions, W3cV2LocalizedValueTransformer, W3cV2Presentation, W3cV2PresentationOptions, W3cV2RefreshService, W3cV2RefreshServiceOptions, W3cV2SdJwt, W3cV2SdJwtCredentialService, W3cV2SdJwtHeader, W3cV2SdJwtPayload, W3cV2SdJwtSignCredentialOptions, W3cV2SdJwtSignPresentationOptions, W3cV2SdJwtVcPresentOptions, W3cV2SdJwtVerifiableCredential, W3cV2SdJwtVerifiableCredentialOptions, W3cV2SdJwtVerifiablePresentation, W3cV2SdJwtVerifiablePresentationOptions, W3cV2SdJwtVerifyCredentialOptions, W3cV2SdJwtVerifyPresentationOptions, W3cV2SignCredentialOptions, W3cV2SignPresentationOptions, W3cV2StoreCredentialOptions, W3cV2TermsOfUse, W3cV2TermsOfUseOptions, W3cV2VerifiableCredential, W3cV2VerifiableCredentialOptions, W3cV2VerifiableCredentialTransformer, W3cV2VerifyCredentialOptions, W3cV2VerifyCredentialResult, W3cV2VerifyPresentationOptions, W3cV2VerifyPresentationResult, W3cVerifiableCredential, W3cVerifiableCredentialTransformer, W3cVerifiablePresentation, W3cVerifyCredentialOptions, W3cVerifyCredentialResult, W3cVerifyPresentationOptions, W3cVerifyPresentationResult, WebDidResolver, X509Api, X509Certificate, X509CertificateExtensionsOptions, X509CertificateIssuerAndSubjectOptions, X509CertificateOptions, X509CertificateSigningRequestExtensionsOptions, X509CreateCertificateChainOptions, X509CreateCertificateOptions, X509CreateCertificateSigningRequestOptions, X509Error, X509ExtendedKeyUsage, X509GetLeafCertificateOptions, X509KeyUsage, X509Module, X509ModuleConfig, X509ModuleConfigOptions, X509ParseCertificateOptions, X509ParseCertificateSigningRequestOptions, X509Service, X509ValidateCertificateChainOptions, X509VerificationContext, X509VerificationTypeCredential, X509VerificationTypeOauth2ClientAttestation, X509VerificationTypeOauth2SecuredAuthorizationRequest, X509VerificationTypeOpenId4VciCredentialIssuerMetadata, X509VerificationTypeOpenId4VciKeyAttestation, type XOR, ZodValidationError, asArray, base64ToBase64URL, canUseInstanceFromCredentialRecord, convertName, convertPublicKeyToX25519, createAuthorityKeyIdentifierExtension, createBasicConstraintsExtension, createCrlDistributionPointsExtension, createExtendedKeyUsagesExtension, createIssuerAlternativeNameExtension, createKeyUsagesExtension, createPeerDidDocumentFromServices, createSubjectAlternativeNameExtension, createSubjectKeyIdentifierExtension, dcqlGetPresentationsToCreate, decodeSdJwt, deepEquality, deriveProof, didDocumentJsonToNumAlgo1Did, didDocumentToNumAlgo2Did, didDocumentToNumAlgo4Did, didKeyToEd25519PublicJwk, didKeyToVerkey, equalsIgnoreOrder, equalsWithOrder, extractPresentationsWithDescriptorsFromSubmission, extractX509CertificatesFromJwt, filterContextCorrelationId, findMatchingEd25519Key, findVerificationMethodByKeyType, getAlternativeDidsForPeerDid, getApiForModuleByName, getDirFromFilePath, getDomainFromUrl, getEcdsaSecp256k1VerificationKey2019, getEd25519VerificationKey2018, getEd25519VerificationKey2020, getJsonWebKey2020, getKmsKeyIdForVerifiacationMethod, getMultikey, getNumAlgoFromPeerDid, getPublicJwkFromEcdsaSecp256k1VerificationKey2019, getPublicJwkFromEd25519VerificationKey2018, getPublicJwkFromEd25519VerificationKey2020, getPublicJwkFromJsonWebKey2020, getPublicJwkFromMultikey, getPublicJwkFromVerificationMethod, getPublicJwkFrommX25519KeyAgreementKey2019, getRegisteredModuleByInstance, getRegisteredModuleByName, getX25519KeyAgreementKey2019, inject, injectAll, injectable, isDid, isDidKey, isEcdsaSecp256k1VerificationKey2019, isEd25519VerificationKey2018, isEd25519VerificationKey2020, isJsonObject, isJsonWebKey2020, isMdocSupportedSignatureAlgorithm, isMultikey, isNonEmptyArray, isStorageUpToDate, isValidPeerDid, isX25519KeyAgreementKey2019, joinUriParts, jwaAlgorithmToKeySignParams, keyDidEd25519, keyDidX25519, keyParamsToJwaAlgorithm, mapNonEmptyArray, parseDid, publicJwkToCryptoKeyAlgorithm, replaceError, sdJwtVcHasher, serviceTypes, tryParseDid, useInstanceFromCredentialRecord, utils, vcLibraries, verkeyToDidKey, verkeyToPublicJwk, w3cDate };
 //# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGM"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsGM"}

package/build/index.mjs

@@ -19,6 +19,7 @@ import { Sha256 } from "./crypto/hashes/Sha256.mjs";
 import { Sha384 } from "./crypto/hashes/Sha384.mjs";
 import { Sha512 } from "./crypto/hashes/Sha512.mjs";
 import { Hasher } from "./crypto/hashes/Hasher.mjs";
+import { IntegrityVerifier } from "./utils/IntegrityVerifier.mjs";
 import { JsonEncoder } from "./utils/JsonEncoder.mjs";
 import { MessageValidator } from "./utils/MessageValidator.mjs";
 import { JsonTransformer } from "./utils/JsonTransformer.mjs";
@@ -240,5 +241,5 @@ const utils = {
 };
 
 //#endregion
-export { ANONCREDS_DATA_INTEGRITY_CRYPTOSUITE, Agent, AgentConfig, AgentContext, AnonCredsDataIntegrityServiceSymbol, BaseAgent, BaseLogger, BaseRecord, Buffer, CREDENTIALS_CONTEXT_V1_URL, CREDENTIALS_CONTEXT_V2_URL, CREDENTIALS_ISSUER_URL, CacheModule, CacheModuleConfig, CachedStorageService, CertificateSigningRequest, ClaimFormat, ClassValidationError, ConsoleLogger, CredentialIssuancePurpose, CredentialMultiInstanceState, CredentialMultiInstanceUseMode, CredoError, CredoWebCrypto, CredoWebCryptoKey, DID_V1_CONTEXT_URL, DataIntegrityProof, DateOnly, DateTransformer, DcqlError, DcqlModule, DcqlService, DefaultAgentContextProvider, DependencyManager, DidCommV1Service, LegacyDidCommV2Service as DidCommV2Service, DidDocument, DidDocumentBuilder, DidDocumentRole, DidDocumentService, DidJwk, DidKey, DidRecord, DidRecordMetadataKeys, DidRegistrarService, DidRepository, DidResolverService, DidsApi, DidsModule, DidsModuleConfig, DifPresentationExchangeError, DifPresentationExchangeModule, DifPresentationExchangeService, PresentationSubmissionLocation as DifPresentationExchangeSubmissionLocation, ENVELOPED_VERIFIABLE_CREDENTIAL_TYPE, ENVELOPED_VERIFIABLE_PRESENTATION_TYPE, EXPANDED_TYPE_CREDENTIALS_CONTEXT_V1_VC_TYPE, Ed25519Signature2018, Ed25519Signature2020, EventEmitter, GenericRecord, GenericRecordsApi, GenericRecordsModule, Hasher, InMemoryLruCache, IndyAgentService, InjectionSymbols, IsEnvelopedVerifiableCredentialType, IsEnvelopedVerifiablePresentationType, IsStringOrInstance, IsStringOrInstanceOrArrayOfInstances, IsStringOrStringArray, IsStringOrVerificationMethod, IsUri, IsW3cCredentialSubject, IsW3cIssuer, IsW3cV2Issuer, JsonEncoder, JsonTransformer, JwkDidRegistrar, JwkDidResolver, JwsLinkedDataSignature, JwsService, Jwt, JwtPayload, KeyDidRegistrar, KeyDidResolver, kms_exports as Kms, LdKeyPair, LogLevel, Mdoc, MdocApi, MdocDeviceResponse, MdocError, MdocModule, MdocRecord, MdocRepository, MdocService, MessageValidator, Metadata, MultiBaseEncoder, MultiHashEncoder, DidCommV2Service as NewDidCommV2Service, DidCommV2ServiceEndpoint as NewDidCommV2ServiceEndpoint, PeerDidNumAlgo, PeerDidRegistrar, PeerDidResolver, RecordDuplicateError, RecordNotFoundError, Repository, RepositoryEventTypes, SECURITY_CONTEXT_SECP256k1_URL, SECURITY_CONTEXT_URL, SECURITY_CONTEXT_V1_URL, SECURITY_CONTEXT_V2_URL, SECURITY_CONTEXT_V3_URL, SECURITY_JWS_CONTEXT_URL, SECURITY_PROOF_URL, SECURITY_SIGNATURE_URL, SECURITY_X25519_CONTEXT_URL, SdJwtVcApi, SdJwtVcError, SdJwtVcModule, SdJwtVcRecord, SdJwtVcRepository, SdJwtVcService, ServiceTransformer, Sha1, Sha256, Sha384, Sha512, SignatureSuiteRegistry, SignatureSuiteToken, SingleContextLruCacheRecord, SingleContextStorageLruCache, StorageUpdateService, StorageVersionRecord, StorageVersionRepository, TypedArrayEncoder, UpdateAssistant, VERIFIABLE_CREDENTIAL_TYPE, VERIFIABLE_PRESENTATION_TYPE, VERIFICATION_METHOD_TYPE_ECDSA_SECP256K1_VERIFICATION_KEY_2019, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020, VERIFICATION_METHOD_TYPE_JSON_WEB_KEY_2020, VERIFICATION_METHOD_TYPE_MULTIKEY, VERIFICATION_METHOD_TYPE_X25519_KEY_AGREEMENT_KEY_2019, VerificationMethod, VerificationMethodTransformer, W3cCredential, W3cCredentialRecord, W3cCredentialRepository, W3cCredentialSchema, W3cCredentialService, W3cCredentialStatus, W3cCredentialSubject, W3cCredentialSubjectTransformer, W3cCredentialsApi, W3cCredentialsModule, W3cCredentialsModuleConfig, W3cIssuer, W3cIssuerTransformer, W3cJsonLdCredentialService, W3cJsonLdVerifiableCredential, W3cJsonLdVerifiablePresentation, W3cJwtCredentialService, W3cJwtVerifiableCredential, W3cJwtVerifiablePresentation, W3cPresentation, W3cV2Credential, W3cV2CredentialRecord, W3cV2CredentialRepository, W3cV2CredentialSchema, W3cV2CredentialService, W3cV2CredentialStatus, W3cV2CredentialSubject, W3cV2CredentialsApi, W3cV2CredentialsModule, W3cV2EnvelopedVerifiableCredential, W3cV2EnvelopedVerifiableCredentialTransformer, W3cV2EnvelopedVerifiablePresentation, W3cV2Evidence, W3cV2Issuer, W3cV2IssuerTransformer, W3cV2JwtCredentialService, W3cV2JwtVerifiableCredential, W3cV2JwtVerifiablePresentation, W3cV2LocalizedValue, W3cV2LocalizedValueTransformer, W3cV2Presentation, W3cV2RefreshService, W3cV2SdJwtCredentialService, W3cV2SdJwtVerifiableCredential, W3cV2SdJwtVerifiablePresentation, W3cV2TermsOfUse, W3cV2VerifiableCredentialTransformer, W3cVerifiableCredentialTransformer, WebDidResolver, X509Api, X509Certificate, X509Error, X509ExtendedKeyUsage, X509KeyUsage, X509Module, X509ModuleConfig, X509Service, ZodValidationError, asArray, base64ToBase64URL, canUseInstanceFromCredentialRecord, convertName, convertPublicKeyToX25519, createAuthorityKeyIdentifierExtension, createBasicConstraintsExtension, createCrlDistributionPointsExtension, createExtendedKeyUsagesExtension, createIssuerAlternativeNameExtension, createKeyUsagesExtension, createPeerDidDocumentFromServices, createSubjectAlternativeNameExtension, createSubjectKeyIdentifierExtension, dcqlGetPresentationsToCreate, decodeSdJwt, deepEquality, deriveProof, didDocumentJsonToNumAlgo1Did, didDocumentToNumAlgo2Did, didDocumentToNumAlgo4Did, didKeyToEd25519PublicJwk, didKeyToVerkey, equalsIgnoreOrder, equalsWithOrder, extractPresentationsWithDescriptorsFromSubmission, extractX509CertificatesFromJwt, filterContextCorrelationId, findMatchingEd25519Key, findVerificationMethodByKeyType, getAlternativeDidsForPeerDid, getApiForModuleByName, getDirFromFilePath, getDomainFromUrl, getEcdsaSecp256k1VerificationKey2019, getEd25519VerificationKey2018, getEd25519VerificationKey2020, getJsonWebKey2020, getKmsKeyIdForVerifiacationMethod, getMultikey, getNumAlgoFromPeerDid, getPublicJwkFromEcdsaSecp256k1VerificationKey2019, getPublicJwkFromEd25519VerificationKey2018, getPublicJwkFromEd25519VerificationKey2020, getPublicJwkFromJsonWebKey2020, getPublicJwkFromMultikey, getPublicJwkFromVerificationMethod, getPublicJwkFrommX25519KeyAgreementKey2019, getRegisteredModuleByInstance, getRegisteredModuleByName, getX25519KeyAgreementKey2019, inject, injectAll, injectable, isDid, isDidKey, isEcdsaSecp256k1VerificationKey2019, isEd25519VerificationKey2018, isEd25519VerificationKey2020, isJsonObject, isJsonWebKey2020, isMdocSupportedSignatureAlgorithm, isMultikey, isNonEmptyArray, isStorageUpToDate, isValidPeerDid, isX25519KeyAgreementKey2019, joinUriParts, jwaAlgorithmToKeySignParams, keyDidEd25519, keyDidX25519, keyParamsToJwaAlgorithm, mapNonEmptyArray, parseDid, publicJwkToCryptoKeyAlgorithm, replaceError, sdJwtVcHasher, serviceTypes, tryParseDid, useInstanceFromCredentialRecord, utils, vcLibraries, verkeyToDidKey, verkeyToPublicJwk, w3cDate };
+export { ANONCREDS_DATA_INTEGRITY_CRYPTOSUITE, Agent, AgentConfig, AgentContext, AnonCredsDataIntegrityServiceSymbol, BaseAgent, BaseLogger, BaseRecord, Buffer, CREDENTIALS_CONTEXT_V1_URL, CREDENTIALS_CONTEXT_V2_URL, CREDENTIALS_ISSUER_URL, CacheModule, CacheModuleConfig, CachedStorageService, CertificateSigningRequest, ClaimFormat, ClassValidationError, ConsoleLogger, CredentialIssuancePurpose, CredentialMultiInstanceState, CredentialMultiInstanceUseMode, CredoError, CredoWebCrypto, CredoWebCryptoKey, DID_V1_CONTEXT_URL, DataIntegrityProof, DateOnly, DateTransformer, DcqlError, DcqlModule, DcqlService, DefaultAgentContextProvider, DependencyManager, DidCommV1Service, LegacyDidCommV2Service as DidCommV2Service, DidDocument, DidDocumentBuilder, DidDocumentRole, DidDocumentService, DidJwk, DidKey, DidRecord, DidRecordMetadataKeys, DidRegistrarService, DidRepository, DidResolverService, DidsApi, DidsModule, DidsModuleConfig, DifPresentationExchangeError, DifPresentationExchangeModule, DifPresentationExchangeService, PresentationSubmissionLocation as DifPresentationExchangeSubmissionLocation, ENVELOPED_VERIFIABLE_CREDENTIAL_TYPE, ENVELOPED_VERIFIABLE_PRESENTATION_TYPE, EXPANDED_TYPE_CREDENTIALS_CONTEXT_V1_VC_TYPE, Ed25519Signature2018, Ed25519Signature2020, EventEmitter, GenericRecord, GenericRecordsApi, GenericRecordsModule, Hasher, InMemoryLruCache, IndyAgentService, InjectionSymbols, IntegrityVerifier, IsEnvelopedVerifiableCredentialType, IsEnvelopedVerifiablePresentationType, IsStringOrInstance, IsStringOrInstanceOrArrayOfInstances, IsStringOrStringArray, IsStringOrVerificationMethod, IsUri, IsW3cCredentialSubject, IsW3cIssuer, IsW3cV2Issuer, JsonEncoder, JsonTransformer, JwkDidRegistrar, JwkDidResolver, JwsLinkedDataSignature, JwsService, Jwt, JwtPayload, KeyDidRegistrar, KeyDidResolver, kms_exports as Kms, LdKeyPair, LogLevel, Mdoc, MdocApi, MdocDeviceResponse, MdocError, MdocModule, MdocRecord, MdocRepository, MdocService, MessageValidator, Metadata, MultiBaseEncoder, MultiHashEncoder, DidCommV2Service as NewDidCommV2Service, DidCommV2ServiceEndpoint as NewDidCommV2ServiceEndpoint, PeerDidNumAlgo, PeerDidRegistrar, PeerDidResolver, RecordDuplicateError, RecordNotFoundError, Repository, RepositoryEventTypes, SECURITY_CONTEXT_SECP256k1_URL, SECURITY_CONTEXT_URL, SECURITY_CONTEXT_V1_URL, SECURITY_CONTEXT_V2_URL, SECURITY_CONTEXT_V3_URL, SECURITY_JWS_CONTEXT_URL, SECURITY_PROOF_URL, SECURITY_SIGNATURE_URL, SECURITY_X25519_CONTEXT_URL, SdJwtVcApi, SdJwtVcError, SdJwtVcModule, SdJwtVcRecord, SdJwtVcRepository, SdJwtVcService, ServiceTransformer, Sha1, Sha256, Sha384, Sha512, SignatureSuiteRegistry, SignatureSuiteToken, SingleContextLruCacheRecord, SingleContextStorageLruCache, StorageUpdateService, StorageVersionRecord, StorageVersionRepository, TypedArrayEncoder, UpdateAssistant, VERIFIABLE_CREDENTIAL_TYPE, VERIFIABLE_PRESENTATION_TYPE, VERIFICATION_METHOD_TYPE_ECDSA_SECP256K1_VERIFICATION_KEY_2019, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020, VERIFICATION_METHOD_TYPE_JSON_WEB_KEY_2020, VERIFICATION_METHOD_TYPE_MULTIKEY, VERIFICATION_METHOD_TYPE_X25519_KEY_AGREEMENT_KEY_2019, VerificationMethod, VerificationMethodTransformer, W3cCredential, W3cCredentialRecord, W3cCredentialRepository, W3cCredentialSchema, W3cCredentialService, W3cCredentialStatus, W3cCredentialSubject, W3cCredentialSubjectTransformer, W3cCredentialsApi, W3cCredentialsModule, W3cCredentialsModuleConfig, W3cIssuer, W3cIssuerTransformer, W3cJsonLdCredentialService, W3cJsonLdVerifiableCredential, W3cJsonLdVerifiablePresentation, W3cJwtCredentialService, W3cJwtVerifiableCredential, W3cJwtVerifiablePresentation, W3cPresentation, W3cV2Credential, W3cV2CredentialRecord, W3cV2CredentialRepository, W3cV2CredentialSchema, W3cV2CredentialService, W3cV2CredentialStatus, W3cV2CredentialSubject, W3cV2CredentialsApi, W3cV2CredentialsModule, W3cV2EnvelopedVerifiableCredential, W3cV2EnvelopedVerifiableCredentialTransformer, W3cV2EnvelopedVerifiablePresentation, W3cV2Evidence, W3cV2Issuer, W3cV2IssuerTransformer, W3cV2JwtCredentialService, W3cV2JwtVerifiableCredential, W3cV2JwtVerifiablePresentation, W3cV2LocalizedValue, W3cV2LocalizedValueTransformer, W3cV2Presentation, W3cV2RefreshService, W3cV2SdJwtCredentialService, W3cV2SdJwtVerifiableCredential, W3cV2SdJwtVerifiablePresentation, W3cV2TermsOfUse, W3cV2VerifiableCredentialTransformer, W3cVerifiableCredentialTransformer, WebDidResolver, X509Api, X509Certificate, X509Error, X509ExtendedKeyUsage, X509KeyUsage, X509Module, X509ModuleConfig, X509Service, ZodValidationError, asArray, base64ToBase64URL, canUseInstanceFromCredentialRecord, convertName, convertPublicKeyToX25519, createAuthorityKeyIdentifierExtension, createBasicConstraintsExtension, createCrlDistributionPointsExtension, createExtendedKeyUsagesExtension, createIssuerAlternativeNameExtension, createKeyUsagesExtension, createPeerDidDocumentFromServices, createSubjectAlternativeNameExtension, createSubjectKeyIdentifierExtension, dcqlGetPresentationsToCreate, decodeSdJwt, deepEquality, deriveProof, didDocumentJsonToNumAlgo1Did, didDocumentToNumAlgo2Did, didDocumentToNumAlgo4Did, didKeyToEd25519PublicJwk, didKeyToVerkey, equalsIgnoreOrder, equalsWithOrder, extractPresentationsWithDescriptorsFromSubmission, extractX509CertificatesFromJwt, filterContextCorrelationId, findMatchingEd25519Key, findVerificationMethodByKeyType, getAlternativeDidsForPeerDid, getApiForModuleByName, getDirFromFilePath, getDomainFromUrl, getEcdsaSecp256k1VerificationKey2019, getEd25519VerificationKey2018, getEd25519VerificationKey2020, getJsonWebKey2020, getKmsKeyIdForVerifiacationMethod, getMultikey, getNumAlgoFromPeerDid, getPublicJwkFromEcdsaSecp256k1VerificationKey2019, getPublicJwkFromEd25519VerificationKey2018, getPublicJwkFromEd25519VerificationKey2020, getPublicJwkFromJsonWebKey2020, getPublicJwkFromMultikey, getPublicJwkFromVerificationMethod, getPublicJwkFrommX25519KeyAgreementKey2019, getRegisteredModuleByInstance, getRegisteredModuleByName, getX25519KeyAgreementKey2019, inject, injectAll, injectable, isDid, isDidKey, isEcdsaSecp256k1VerificationKey2019, isEd25519VerificationKey2018, isEd25519VerificationKey2020, isJsonObject, isJsonWebKey2020, isMdocSupportedSignatureAlgorithm, isMultikey, isNonEmptyArray, isStorageUpToDate, isValidPeerDid, isX25519KeyAgreementKey2019, joinUriParts, jwaAlgorithmToKeySignParams, keyDidEd25519, keyDidX25519, keyParamsToJwaAlgorithm, mapNonEmptyArray, parseDid, publicJwkToCryptoKeyAlgorithm, replaceError, sdJwtVcHasher, serviceTypes, tryParseDid, useInstanceFromCredentialRecord, utils, vcLibraries, verkeyToDidKey, verkeyToPublicJwk, w3cDate };
 //# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["// reflect-metadata used for class-transformer + class-validator\nimport 'reflect-metadata'\n\nexport * from './agent'\nexport { Agent } from './agent/Agent'\nexport { AgentConfig } from './agent/AgentConfig'\nexport type { AgentDependencies } from './agent/AgentDependencies'\nexport type { AgentApi, DefaultAgentModules, EmptyModuleMap, ModulesMap } from './agent/AgentModules'\nexport { BaseAgent } from './agent/BaseAgent'\nexport { EventEmitter } from './agent/EventEmitter'\nexport * from './agent/Events'\nexport { InjectionSymbols } from './constants'\nexport * from './crypto'\nexport * from './error'\nexport * from './logger'\nexport * from './modules/cache'\nexport * from './modules/dcql'\nexport * from './modules/dids'\nexport { tryParseDid } from './modules/dids/domain/parse'\n// TODO: Clean up these exports used by DIDComm module\nexport {\n  didKeyToEd25519PublicJwk,\n  didKeyToVerkey,\n  isDidKey,\n  verkeyToDidKey,\n  verkeyToPublicJwk,\n} from './modules/dids/helpers'\nexport { didDocumentJsonToNumAlgo1Did } from './modules/dids/methods/peer/peerDidNumAlgo1'\nexport { didDocumentToNumAlgo2Did } from './modules/dids/methods/peer/peerDidNumAlgo2'\nexport { didDocumentToNumAlgo4Did } from './modules/dids/methods/peer/peerDidNumAlgo4'\nexport { DidRecordMetadataKeys } from './modules/dids/repository/didRecordMetadataTypes'\nexport * from './modules/dif-presentation-exchange'\nexport * from './modules/generic-records'\nexport * as Kms from './modules/kms'\nexport * from './modules/mdoc'\nexport * from './modules/sd-jwt-vc'\nexport * from './modules/vc'\nexport * from './modules/x509'\nexport * from './plugins'\nexport * from './storage/BaseRecord'\nexport type { DownloadToFileOptions, FileSystem } from './storage/FileSystem'\nexport { Metadata, type MetadataBase } from './storage/Metadata'\nexport * from './storage/migration'\nexport type { UpdateConfig, V0_1ToV0_2UpdateConfig } from './storage/migration/updates'\nexport { Repository } from './storage/Repository'\nexport * from './storage/RepositoryEvents'\nexport type { BaseRecordConstructor, Query, QueryOptions, SimpleQuery, StorageService } from './storage/StorageService'\nexport type {\n  AnyUint8Array,\n  CanBePromise,\n  InitConfig,\n  JsonArray,\n  JsonObject,\n  JsonValue,\n  NonEmptyArray,\n  Optional,\n  ResolvedDidCommService,\n  SingleOrArray,\n  Uint8ArrayBuffer,\n  XOR,\n} from './types'\nexport { isJsonObject, isNonEmptyArray, mapNonEmptyArray } from './types'\nexport {\n  asArray,\n  type BaseName,\n  Buffer,\n  DateTransformer,\n  deepEquality,\n  equalsIgnoreOrder,\n  equalsWithOrder,\n  IsStringOrInstance,\n  IsStringOrInstanceOrArrayOfInstances,\n  IsStringOrStringArray,\n  IsUri,\n  isDid,\n  JsonEncoder,\n  JsonTransformer,\n  MessageValidator,\n  MultiBaseEncoder,\n  MultiHashEncoder,\n  TypedArrayEncoder,\n} from './utils'\nexport { base64ToBase64URL } from './utils/base64'\nexport type {\n  CredentialMultiInstanceUseUpdateMode,\n  UseInstanceFromCredentialRecordOptions,\n  UseInstanceFromCredentialRecordReturn,\n} from './utils/credentialUse'\nexport { canUseInstanceFromCredentialRecord, useInstanceFromCredentialRecord } from './utils/credentialUse'\nexport { CredentialMultiInstanceState, CredentialMultiInstanceUseMode } from './utils/credentialUseTypes'\nexport { getDomainFromUrl } from './utils/domain'\nexport type { Constructable, Constructor, UnionToIntersection } from './utils/mixins'\nexport { getDirFromFilePath, joinUriParts } from './utils/path'\nexport type { VersionString } from './utils/version'\n\nimport { indyDidFromPublicKeyBase58 } from './utils/did'\nimport { areObjectsEqual } from './utils/objectEquality'\nimport timestamp, { addSecondsToDate, dateToSeconds, nowInSeconds } from './utils/timestamp'\nimport { getProtocolScheme } from './utils/uri'\nimport { isValidUuid, uuid } from './utils/uuid'\n\nconst utils = {\n  areObjectsEqual,\n  uuid,\n  isValidUuid,\n  getProtocolScheme,\n  timestamp,\n  indyDidFromPublicKeyBase58,\n  nowInSeconds,\n  dateToSeconds,\n  addSecondsToDate,\n}\n\nexport { utils }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,MAAM,QAAQ;CACZ;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["// reflect-metadata used for class-transformer + class-validator\nimport 'reflect-metadata'\n\nexport * from './agent'\nexport { Agent } from './agent/Agent'\nexport { AgentConfig } from './agent/AgentConfig'\nexport type { AgentDependencies } from './agent/AgentDependencies'\nexport type { AgentApi, DefaultAgentModules, EmptyModuleMap, ModulesMap } from './agent/AgentModules'\nexport { BaseAgent } from './agent/BaseAgent'\nexport { EventEmitter } from './agent/EventEmitter'\nexport * from './agent/Events'\nexport { InjectionSymbols } from './constants'\nexport * from './crypto'\nexport * from './error'\nexport * from './logger'\nexport * from './modules/cache'\nexport * from './modules/dcql'\nexport * from './modules/dids'\nexport { tryParseDid } from './modules/dids/domain/parse'\n// TODO: Clean up these exports used by DIDComm module\nexport {\n  didKeyToEd25519PublicJwk,\n  didKeyToVerkey,\n  isDidKey,\n  verkeyToDidKey,\n  verkeyToPublicJwk,\n} from './modules/dids/helpers'\nexport { didDocumentJsonToNumAlgo1Did } from './modules/dids/methods/peer/peerDidNumAlgo1'\nexport { didDocumentToNumAlgo2Did } from './modules/dids/methods/peer/peerDidNumAlgo2'\nexport { didDocumentToNumAlgo4Did } from './modules/dids/methods/peer/peerDidNumAlgo4'\nexport { DidRecordMetadataKeys } from './modules/dids/repository/didRecordMetadataTypes'\nexport * from './modules/dif-presentation-exchange'\nexport * from './modules/generic-records'\nexport * as Kms from './modules/kms'\nexport * from './modules/mdoc'\nexport * from './modules/sd-jwt-vc'\nexport * from './modules/vc'\nexport * from './modules/x509'\nexport * from './plugins'\nexport * from './storage/BaseRecord'\nexport type { DownloadToFileOptions, FileSystem } from './storage/FileSystem'\nexport { Metadata, type MetadataBase } from './storage/Metadata'\nexport * from './storage/migration'\nexport type { UpdateConfig, V0_1ToV0_2UpdateConfig } from './storage/migration/updates'\nexport { Repository } from './storage/Repository'\nexport * from './storage/RepositoryEvents'\nexport type { BaseRecordConstructor, Query, QueryOptions, SimpleQuery, StorageService } from './storage/StorageService'\nexport type {\n  AnyUint8Array,\n  CanBePromise,\n  InitConfig,\n  JsonArray,\n  JsonObject,\n  JsonValue,\n  NonEmptyArray,\n  Optional,\n  ResolvedDidCommService,\n  SingleOrArray,\n  Uint8ArrayBuffer,\n  XOR,\n} from './types'\nexport { isJsonObject, isNonEmptyArray, mapNonEmptyArray } from './types'\nexport {\n  asArray,\n  type BaseName,\n  Buffer,\n  DateTransformer,\n  deepEquality,\n  equalsIgnoreOrder,\n  equalsWithOrder,\n  IntegrityVerifier,\n  IsStringOrInstance,\n  IsStringOrInstanceOrArrayOfInstances,\n  IsStringOrStringArray,\n  IsUri,\n  isDid,\n  JsonEncoder,\n  JsonTransformer,\n  MessageValidator,\n  MultiBaseEncoder,\n  MultiHashEncoder,\n  TypedArrayEncoder,\n} from './utils'\nexport { base64ToBase64URL } from './utils/base64'\nexport type {\n  CredentialMultiInstanceUseUpdateMode,\n  UseInstanceFromCredentialRecordOptions,\n  UseInstanceFromCredentialRecordReturn,\n} from './utils/credentialUse'\nexport { canUseInstanceFromCredentialRecord, useInstanceFromCredentialRecord } from './utils/credentialUse'\nexport { CredentialMultiInstanceState, CredentialMultiInstanceUseMode } from './utils/credentialUseTypes'\nexport { getDomainFromUrl } from './utils/domain'\nexport type { Constructable, Constructor, UnionToIntersection } from './utils/mixins'\nexport { getDirFromFilePath, joinUriParts } from './utils/path'\nexport type { VersionString } from './utils/version'\n\nimport { indyDidFromPublicKeyBase58 } from './utils/did'\nimport { areObjectsEqual } from './utils/objectEquality'\nimport timestamp, { addSecondsToDate, dateToSeconds, nowInSeconds } from './utils/timestamp'\nimport { getProtocolScheme } from './utils/uri'\nimport { isValidUuid, uuid } from './utils/uuid'\n\nconst utils = {\n  areObjectsEqual,\n  uuid,\n  isValidUuid,\n  getProtocolScheme,\n  timestamp,\n  indyDidFromPublicKeyBase58,\n  nowInSeconds,\n  dateToSeconds,\n  addSecondsToDate,\n}\n\nexport { utils }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsGA,MAAM,QAAQ;CACZ;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.d.mts

@@ -10,7 +10,7 @@ type Jwk = KmsJwkPublicEc & {
 declare class P256PublicJwk implements PublicJwkType<Jwk> {
   readonly jwk: Jwk;
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
-  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   static multicodecPrefix: number;
   supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"P256PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P256PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}
+{"version":3,"file":"P256PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P256PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,yCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.mjs

@@ -7,7 +7,7 @@ import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mj
 var P256PublicJwk = class P256PublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
-		this.supportedEncryptionKeyAgreementAlgorithms = P256PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = P256PublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 		this.supportedSignatureAlgorithms = P256PublicJwk.supportedSignatureAlgorithms;
 		this.multicodecPrefix = P256PublicJwk.multicodecPrefix;
 	}
@@ -36,7 +36,7 @@ var P256PublicJwk = class P256PublicJwk {
 	}
 };
 P256PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES256];
-P256PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+P256PublicJwk.supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
 P256PublicJwk.multicodecPrefix = 4608;
 
 //#endregion

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"P256PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P256PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-256' }\n\nexport class P256PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES256]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4608\n\n  public supportedEncryptionKeyAgreementAlgorithms = P256PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P256PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P256PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-256')\n    return new P256PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-256')\n    return new P256PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,cAAc;OAC1D,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,2CAA2C,CAAC,+BAA+B,QAAQ;cACnF,mBAAmB"}
+{"version":3,"file":"P256PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P256PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-256' }\n\nexport class P256PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES256]\n  public static supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4608\n\n  public supportedEncryptionKeyAgreementAlgorithms = P256PublicJwk.supportedEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P256PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P256PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-256')\n    return new P256PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-256')\n    return new P256PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,cAAc;OAC1D,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,4CAA4C,CAAC,+BAA+B,QAAQ;cACpF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.d.mts

@@ -10,7 +10,7 @@ type Jwk = KmsJwkPublicEc & {
 declare class P384PublicJwk implements PublicJwkType<Jwk> {
   readonly jwk: Jwk;
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
-  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   static multicodecPrefix: number;
   supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"P384PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P384PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}
+{"version":3,"file":"P384PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P384PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,yCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.mjs

@@ -7,7 +7,7 @@ import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mj
 var P384PublicJwk = class P384PublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
-		this.supportedEncryptionKeyAgreementAlgorithms = P384PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = P384PublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 		this.supportedSignatureAlgorithms = P384PublicJwk.supportedSignatureAlgorithms;
 		this.multicodecPrefix = P384PublicJwk.multicodecPrefix;
 	}
@@ -36,7 +36,7 @@ var P384PublicJwk = class P384PublicJwk {
 	}
 };
 P384PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES384];
-P384PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+P384PublicJwk.supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
 P384PublicJwk.multicodecPrefix = 4609;
 
 //#endregion

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"P384PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P384PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-384' }\n\nexport class P384PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES384]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4609\n\n  public supportedEncryptionKeyAgreementAlgorithms = P384PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P384PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P384PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-384')\n    return new P384PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-384')\n    return new P384PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,cAAc;OAC1D,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,2CAA2C,CAAC,+BAA+B,QAAQ;cACnF,mBAAmB"}
+{"version":3,"file":"P384PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P384PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-384' }\n\nexport class P384PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES384]\n  public static supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4609\n\n  public supportedEncryptionKeyAgreementAlgorithms = P384PublicJwk.supportedEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P384PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P384PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-384')\n    return new P384PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-384')\n    return new P384PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,cAAc;OAC1D,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,4CAA4C,CAAC,+BAA+B,QAAQ;cACpF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.d.mts

@@ -10,7 +10,7 @@ type Jwk = KmsJwkPublicEc & {
 declare class P521PublicJwk implements PublicJwkType<Jwk> {
   readonly jwk: Jwk;
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
-  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   static multicodecPrefix: number;
   supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"P521PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P521PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}
+{"version":3,"file":"P521PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P521PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,yCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.mjs

@@ -7,7 +7,7 @@ import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mj
 var P521PublicJwk = class P521PublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
-		this.supportedEncryptionKeyAgreementAlgorithms = P521PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = P521PublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 		this.supportedSignatureAlgorithms = P521PublicJwk.supportedSignatureAlgorithms;
 		this.multicodecPrefix = P521PublicJwk.multicodecPrefix;
 	}
@@ -36,7 +36,7 @@ var P521PublicJwk = class P521PublicJwk {
 	}
 };
 P521PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES512];
-P521PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+P521PublicJwk.supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
 P521PublicJwk.multicodecPrefix = 4610;
 
 //#endregion

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"P521PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P521PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-521' }\n\nexport class P521PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES512]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4610\n\n  public supportedEncryptionKeyAgreementAlgorithms = P521PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P521PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P521PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-521')\n    return new P521PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-521')\n    return new P521PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,cAAc;OAC1D,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,2CAA2C,CAAC,+BAA+B,QAAQ;cACnF,mBAAmB"}
+{"version":3,"file":"P521PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P521PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-521' }\n\nexport class P521PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES512]\n  public static supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4610\n\n  public supportedEncryptionKeyAgreementAlgorithms = P521PublicJwk.supportedEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P521PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P521PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-521')\n    return new P521PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-521')\n    return new P521PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,cAAc;OAC1D,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,4CAA4C,CAAC,+BAA+B,QAAQ;cACpF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.d.mts

@@ -10,7 +10,7 @@ type Jwk = KmsJwkPublicEc & {
 declare class Secp256k1PublicJwk implements PublicJwkType<Jwk> {
   readonly jwk: Jwk;
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
-  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   static multicodecPrefix: number;
   supportedEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
   supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Secp256k1PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,kBAAA,YAA8B,cAAc;EAFpD,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAmB,EACc,0BADd,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASf,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,WAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApCb,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,WAAA;;;;oBA2BjC;kCAIkB,gBAAa;oCAKX,gBAAa"}
+{"version":3,"file":"Secp256k1PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,kBAAA,YAA8B,cAAc;EAFpD,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAmB,EACc,0BADd,EAAA;EAAyB,OAAA,yCAAA,EAAA,SAAA,EAAA;EASf,OAAA,gBAAA,EAAA,MAAA;EARI,yCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,WAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApCb,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,WAAA;;;;oBA2BjC;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.mjs

@@ -7,7 +7,7 @@ import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mj
 var Secp256k1PublicJwk = class Secp256k1PublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
-		this.supportedEncryptionKeyAgreementAlgorithms = Secp256k1PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = Secp256k1PublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 		this.supportedSignatureAlgorithms = Secp256k1PublicJwk.supportedSignatureAlgorithms;
 		this.multicodecPrefix = Secp256k1PublicJwk.multicodecPrefix;
 	}
@@ -36,7 +36,7 @@ var Secp256k1PublicJwk = class Secp256k1PublicJwk {
 	}
 };
 Secp256k1PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES256K];
-Secp256k1PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+Secp256k1PublicJwk.supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
 Secp256k1PublicJwk.multicodecPrefix = 231;
 
 //#endregion

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Secp256k1PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'secp256k1' }\n\nexport class Secp256k1PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES256K]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 231\n\n  public supportedEncryptionKeyAgreementAlgorithms = Secp256k1PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = Secp256k1PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = Secp256k1PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'secp256k1')\n    return new Secp256k1PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'secp256k1')\n    return new Secp256k1PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,qBAAb,MAAa,mBAAiD;CAS5D,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,mBAAmB;OAC/D,+BAA+B,mBAAmB;OAClD,mBAAmB,mBAAmB;;CAI7C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,mBADC,uBAAuB,WAAW,YAAY,CACxB;;CAGpC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,mBADC,uBAAuB,YAAY,YAAY,CACzB;;;mBArCtB,+BAA6D,CAAC,4BAA4B,OAAO;mBACjG,2CAA2C,CAAC,+BAA+B,QAAQ;mBACnF,mBAAmB"}
+{"version":3,"file":"Secp256k1PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'secp256k1' }\n\nexport class Secp256k1PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES256K]\n  public static supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 231\n\n  public supportedEncryptionKeyAgreementAlgorithms = Secp256k1PublicJwk.supportedEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = Secp256k1PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = Secp256k1PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'secp256k1')\n    return new Secp256k1PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'secp256k1')\n    return new Secp256k1PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,qBAAb,MAAa,mBAAiD;CAS5D,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,mBAAmB;OAC/D,+BAA+B,mBAAmB;OAClD,mBAAmB,mBAAmB;;CAI7C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,mBADC,uBAAuB,WAAW,YAAY,CACxB;;CAGpC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,mBADC,uBAAuB,YAAY,YAAY,CACzB;;;mBArCtB,+BAA6D,CAAC,4BAA4B,OAAO;mBACjG,4CAA4C,CAAC,+BAA+B,QAAQ;mBACpF,mBAAmB"}

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.d.mts

@@ -10,7 +10,7 @@ type Jwk = KmsJwkPublicOkp & {
 declare class Ed25519PublicJwk implements PublicJwkType<Jwk> {
   readonly jwk: Jwk;
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
-  static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[];
+  static supportedEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[];
   static multicodecPrefix: number;
   supportedEncryptionKeyAgreementAlgorithms: ("ECDH-ES" | "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW" | "ECDH-HSALSA20")[];
   supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Ed25519PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAYK,GAAA,GAAM;;;cAEE,gBAAA,YAA4B,cAAc;EAFlD,SAAG,GAAA,EAckC,GAdlC;EAEK,OAAA,4BAAiB,EACgB,0BADhB,EAAA;EAAyB,OAAA,wCAAA,EAKG,6BALH,EAAA;EAYb,OAAA,gBAAA,EAAA,MAAA;EAXI,yCAAA,EAAA,CAAA,SAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,eAAA,CAAA,EAAA;EAIY,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;EAOhB,gBAAA,EAAA,MAAA;mBAAA;EAiBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,SAAA;IAAa,GAAA,EAAA,KAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EAtCf;;;;oBA6BlB;kCAIkB,gBAAa;oCAKX,gBAAa"}
+{"version":3,"file":"Ed25519PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAYK,GAAA,GAAM;;;cAEE,gBAAA,YAA4B,cAAc;EAFlD,SAAG,GAAA,EAckC,GAdlC;EAEK,OAAA,4BAAiB,EACgB,0BADhB,EAAA;EAAyB,OAAA,yCAAA,EAKI,6BALJ,EAAA;EAYb,OAAA,gBAAA,EAAA,MAAA;EAXI,yCAAA,EAAA,CAAA,SAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,eAAA,CAAA,EAAA;EAIa,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;EAOjB,gBAAA,EAAA,MAAA;mBAAA;EAiBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,SAAA;IAAa,GAAA,EAAA,KAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EAtCf;;;;oBA6BlB;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.mjs

@@ -9,7 +9,7 @@ import { convertPublicKeyToX25519 } from "@stablelib/ed25519";
 var Ed25519PublicJwk = class Ed25519PublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
-		this.supportedEncryptionKeyAgreementAlgorithms = Ed25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = Ed25519PublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 		this.supportedSignatureAlgorithms = Ed25519PublicJwk.supportedSignatureAlgorithms;
 		this.multicodecPrefix = Ed25519PublicJwk.multicodecPrefix;
 	}
@@ -40,7 +40,7 @@ var Ed25519PublicJwk = class Ed25519PublicJwk {
 	}
 };
 Ed25519PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.EdDSA, KnownJwaSignatureAlgorithms.Ed25519];
-Ed25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [];
+Ed25519PublicJwk.supportedEncryptionKeyAgreementAlgorithms = [];
 Ed25519PublicJwk.multicodecPrefix = 237;
 
 //#endregion

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Ed25519PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts"],"sourcesContent":["import { convertPublicKeyToX25519 } from '@stablelib/ed25519'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport {\n  type KnownJwaKeyAgreementAlgorithm,\n  type KnownJwaSignatureAlgorithm,\n  KnownJwaSignatureAlgorithms,\n} from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicOkp } from './okpJwk'\nimport { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from './okpPublicKey'\nimport { X25519PublicJwk } from './X25519PublicJwk'\n\ntype Jwk = KmsJwkPublicOkp & { crv: 'Ed25519' }\n\nexport class Ed25519PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [\n    KnownJwaSignatureAlgorithms.EdDSA,\n    KnownJwaSignatureAlgorithms.Ed25519,\n  ]\n  public static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[] = []\n  public static multicodecPrefix = 237\n\n  public supportedEncryptionKeyAgreementAlgorithms = Ed25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = Ed25519PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = Ed25519PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: okpPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for Ed25519\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec() {\n    return okpPublicJwkToPublicKey(this.jwk)\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(publicKey, 'Ed25519')\n    return new Ed25519PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(multicodec, 'Ed25519')\n    return new Ed25519PublicJwk(jwk)\n  }\n\n  public toX25519PublicJwk() {\n    return X25519PublicJwk.fromPublicKey(convertPublicKeyToX25519(this.publicKey.publicKey) as Uint8ArrayBuffer).jwk\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAa,mBAAb,MAAa,iBAA+C;CAY1D,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,iBAAiB;OAC7D,+BAA+B,iBAAiB;OAChD,mBAAmB,iBAAiB;;CAI3C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,wBAAwB,KAAK,IAAI;GAC7C;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAAa;AACtB,SAAO,wBAAwB,KAAK,IAAI;;CAG1C,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,iBADC,wBAAwB,WAAW,UAAU,CACzB;;CAGlC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,iBADC,wBAAwB,YAAY,UAAU,CAC1B;;CAGlC,AAAO,oBAAoB;AACzB,SAAO,gBAAgB,cAAc,yBAAyB,KAAK,UAAU,UAAU,CAAqB,CAAC;;;iBA3CjG,+BAA6D,CACzE,4BAA4B,OAC5B,4BAA4B,QAC7B;iBACa,2CAA4E,EAAE;iBAC9E,mBAAmB"}
+{"version":3,"file":"Ed25519PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts"],"sourcesContent":["import { convertPublicKeyToX25519 } from '@stablelib/ed25519'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport {\n  type KnownJwaKeyAgreementAlgorithm,\n  type KnownJwaSignatureAlgorithm,\n  KnownJwaSignatureAlgorithms,\n} from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicOkp } from './okpJwk'\nimport { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from './okpPublicKey'\nimport { X25519PublicJwk } from './X25519PublicJwk'\n\ntype Jwk = KmsJwkPublicOkp & { crv: 'Ed25519' }\n\nexport class Ed25519PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [\n    KnownJwaSignatureAlgorithms.EdDSA,\n    KnownJwaSignatureAlgorithms.Ed25519,\n  ]\n  public static supportedEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[] = []\n  public static multicodecPrefix = 237\n\n  public supportedEncryptionKeyAgreementAlgorithms = Ed25519PublicJwk.supportedEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = Ed25519PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = Ed25519PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: okpPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for Ed25519\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec() {\n    return okpPublicJwkToPublicKey(this.jwk)\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(publicKey, 'Ed25519')\n    return new Ed25519PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(multicodec, 'Ed25519')\n    return new Ed25519PublicJwk(jwk)\n  }\n\n  public toX25519PublicJwk() {\n    return X25519PublicJwk.fromPublicKey(convertPublicKeyToX25519(this.publicKey.publicKey) as Uint8ArrayBuffer).jwk\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAa,mBAAb,MAAa,iBAA+C;CAY1D,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,iBAAiB;OAC7D,+BAA+B,iBAAiB;OAChD,mBAAmB,iBAAiB;;CAI3C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,wBAAwB,KAAK,IAAI;GAC7C;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAAa;AACtB,SAAO,wBAAwB,KAAK,IAAI;;CAG1C,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,iBADC,wBAAwB,WAAW,UAAU,CACzB;;CAGlC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,iBADC,wBAAwB,YAAY,UAAU,CAC1B;;CAGlC,AAAO,oBAAoB;AACzB,SAAO,gBAAgB,cAAc,yBAAyB,KAAK,UAAU,UAAU,CAAqB,CAAC;;;iBA3CjG,+BAA6D,CACzE,4BAA4B,OAC5B,4BAA4B,QAC7B;iBACa,4CAA6E,EAAE;iBAC/E,mBAAmB"}

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.d.mts

@@ -9,7 +9,7 @@ type Jwk = KmsJwkPublicOkp & {
 };
 declare class X25519PublicJwk implements PublicJwkType<Jwk> {
   readonly jwk: Jwk;
-  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-HSALSA20"[];
+  static supportedEncryptionKeyAgreementAlgorithms: "ECDH-HSALSA20"[];
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
   static multicodecPrefix: number;
   supportedEncryptionKeyAgreementAlgorithms: "ECDH-HSALSA20"[];

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"X25519PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,eAAA,YAA2B,cAAc;EAFjD,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,wCAAgB,EAAA,eAAA,EAAA;EAAyB,OAAA,4BAAA,EAER,0BAFQ,EAAA;EASZ,OAAA,gBAAA,EAAA,MAAA;EAPI,yCAAA,EAAA,eAAA,EAAA;EAOJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;EAiBnB,WAAA,CAAA,GAAA,EAjBmB,GAiBnB;EAIkB,IAAA,SAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,QAAA;IAKX,GAAA,EAAA,KAAA;IAAa,SAAA,eAAA;EAnChB,CAAA;EAAa;;;;oBA0B9B;kCAIkB,gBAAa;oCAKX,gBAAa"}
+{"version":3,"file":"X25519PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,eAAA,YAA2B,cAAc;EAFjD,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,yCAAgB,EAAA,eAAA,EAAA;EAAyB,OAAA,4BAAA,EAER,0BAFQ,EAAA;EASZ,OAAA,gBAAA,EAAA,MAAA;EAPI,yCAAA,EAAA,eAAA,EAAA;EAOJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;EAiBnB,WAAA,CAAA,GAAA,EAjBmB,GAiBnB;EAIkB,IAAA,SAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,QAAA;IAKX,GAAA,EAAA,KAAA;IAAa,SAAA,eAAA;EAnChB,CAAA;EAAa;;;;oBA0B9B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.mjs

@@ -7,7 +7,7 @@ import { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from "./okpPublicKey
 var X25519PublicJwk = class X25519PublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
-		this.supportedEncryptionKeyAgreementAlgorithms = X25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = X25519PublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 		this.supportedSignatureAlgorithms = X25519PublicJwk.supportedSignatureAlgorithms;
 		this.multicodecPrefix = X25519PublicJwk.multicodecPrefix;
 	}
@@ -34,7 +34,7 @@ var X25519PublicJwk = class X25519PublicJwk {
 		return new X25519PublicJwk(okpPublicKeyToPublicJwk(multicodec, "X25519"));
 	}
 };
-X25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_HSALSA20];
+X25519PublicJwk.supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_HSALSA20];
 X25519PublicJwk.supportedSignatureAlgorithms = [];
 X25519PublicJwk.multicodecPrefix = 236;
 

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"X25519PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicOkp } from './okpJwk'\nimport { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from './okpPublicKey'\n\ntype Jwk = KmsJwkPublicOkp & { crv: 'X25519' }\n\nexport class X25519PublicJwk implements PublicJwkType<Jwk> {\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_HSALSA20]\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = []\n  public static multicodecPrefix = 236\n\n  public supportedEncryptionKeyAgreementAlgorithms = X25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = X25519PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = X25519PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: okpPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for X25519\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec() {\n    return okpPublicJwkToPublicKey(this.jwk)\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(publicKey, 'X25519')\n    return new X25519PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(multicodec, 'X25519')\n    return new X25519PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,kBAAb,MAAa,gBAA8C;CASzD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,gBAAgB;OAC5D,+BAA+B,gBAAgB;OAC/C,mBAAmB,gBAAgB;;CAI1C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,wBAAwB,KAAK,IAAI;GAC7C;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAAa;AACtB,SAAO,wBAAwB,KAAK,IAAI;;CAG1C,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,gBADC,wBAAwB,WAAW,SAAS,CACzB;;CAGjC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,gBADC,wBAAwB,YAAY,SAAS,CAC1B;;;gBApCnB,2CAA2C,CAAC,+BAA+B,cAAc;gBACzF,+BAA6D,EAAE;gBAC/D,mBAAmB"}
+{"version":3,"file":"X25519PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicOkp } from './okpJwk'\nimport { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from './okpPublicKey'\n\ntype Jwk = KmsJwkPublicOkp & { crv: 'X25519' }\n\nexport class X25519PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_HSALSA20]\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = []\n  public static multicodecPrefix = 236\n\n  public supportedEncryptionKeyAgreementAlgorithms = X25519PublicJwk.supportedEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = X25519PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = X25519PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: okpPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for X25519\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec() {\n    return okpPublicJwkToPublicKey(this.jwk)\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(publicKey, 'X25519')\n    return new X25519PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(multicodec, 'X25519')\n    return new X25519PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,kBAAb,MAAa,gBAA8C;CASzD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,4CAA4C,gBAAgB;OAC5D,+BAA+B,gBAAgB;OAC/C,mBAAmB,gBAAgB;;CAI1C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,wBAAwB,KAAK,IAAI;GAC7C;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAAa;AACtB,SAAO,wBAAwB,KAAK,IAAI;;CAG1C,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,gBADC,wBAAwB,WAAW,SAAS,CACzB;;CAGjC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,gBADC,wBAAwB,YAAY,SAAS,CAC1B;;;gBApCnB,4CAA4C,CAAC,+BAA+B,cAAc;gBAC1F,+BAA6D,EAAE;gBAC/D,mBAAmB"}

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.d.mts

@@ -6,7 +6,7 @@ import { PublicJwkType } from "../PublicJwk.mjs";
 //#region src/modules/kms/jwk/kty/rsa/RsaPublicJwk.d.ts
 declare class RsaPublicJwk implements PublicJwkType<KmsJwkPublicRsa> {
   readonly jwk: KmsJwkPublicRsa;
-  static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[];
+  static supportedEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[];
   static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
   static multicodecPrefix: number;
   multicodecPrefix: number;

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"RsaPublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/rsa/RsaPublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;cAQa,YAAA,YAAwB,cAAc;gBA0BT;mDAzBgB;uCACZ;EAFjC,OAAA,gBAAa,EAAA,MAAA;EAAyB,gBAAA,EAAA,MAAA;EA0BT,yCAAA,EAAA,CAAA,SAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,eAAA,CAAA,EAAA;EAzBgB,IAAA,4BAAA,CAAA,CAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,CAAA,EAAA;EACZ,WAAA,CAAA,GAAA,EAwBJ,eAxBI;EAwBJ,IAAA,SAAA,CAAA,CAAA,EAAA;;;IAgBf,GAAA,EAAA,KAAA;EAIyB,CAAA;EAAyB;;;EAIjB,IAAA,mBAAA,CAAA,CAAA,EAAA,IAAA;EAlDvB,IAAA,UAAA,CAAA,CAAA,EA0CV,gBA1CU;EAAa,OAAA,aAAA,CAAA,SAAA,EAAA;aA8CE;cAAyB;MAAe;qCAIhD,gBAAgB"}
+{"version":3,"file":"RsaPublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/rsa/RsaPublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;cAQa,YAAA,YAAwB,cAAc;gBA0BT;oDAzBiB;uCACb;EAFjC,OAAA,gBAAa,EAAA,MAAA;EAAyB,gBAAA,EAAA,MAAA;EA0BT,yCAAA,EAAA,CAAA,SAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,eAAA,CAAA,EAAA;EAzBiB,IAAA,4BAAA,CAAA,CAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,CAAA,EAAA;EACb,WAAA,CAAA,GAAA,EAwBJ,eAxBI;EAwBJ,IAAA,SAAA,CAAA,CAAA,EAAA;;;IAgBf,GAAA,EAAA,KAAA;EAIyB,CAAA;EAAyB;;;EAIjB,IAAA,mBAAA,CAAA,CAAA,EAAA,IAAA;EAlDvB,IAAA,UAAA,CAAA,CAAA,EA0CV,gBA1CU;EAAa,OAAA,aAAA,CAAA,SAAA,EAAA;aA8CE;cAAyB;MAAe;qCAIhD,gBAAgB"}

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.mjs

@@ -25,7 +25,7 @@ var RsaPublicJwk = class RsaPublicJwk {
 	constructor(jwk) {
 		this.jwk = jwk;
 		this.multicodecPrefix = RsaPublicJwk.multicodecPrefix;
-		this.supportedEncryptionKeyAgreementAlgorithms = RsaPublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedEncryptionKeyAgreementAlgorithms = RsaPublicJwk.supportedEncryptionKeyAgreementAlgorithms;
 	}
 	get publicKey() {
 		return {
@@ -49,7 +49,7 @@ var RsaPublicJwk = class RsaPublicJwk {
 		throw new KeyManagementError("fromMulticodec not supported for RsaPublicJwk");
 	}
 };
-RsaPublicJwk.supportdEncryptionKeyAgreementAlgorithms = [];
+RsaPublicJwk.supportedEncryptionKeyAgreementAlgorithms = [];
 RsaPublicJwk.supportedSignatureAlgorithms = [
 	"PS256",
 	"RS256",

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"RsaPublicJwk.mjs","names":["jwk: KmsJwkPublicRsa"],"sources":["../../../../../../src/modules/kms/jwk/kty/rsa/RsaPublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport { TypedArrayEncoder } from '../../../../../utils'\nimport { KeyManagementError } from '../../../error/KeyManagementError'\nimport type { KnownJwaKeyAgreementAlgorithm, KnownJwaSignatureAlgorithm } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicRsa } from './rsaJwk'\nimport { rsaPublicJwkToPublicKey, rsaPublicKeyToPublicJwk } from './rsaPublicKey'\n\nexport class RsaPublicJwk implements PublicJwkType<KmsJwkPublicRsa> {\n  public static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[] = []\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [\n    'PS256',\n    'RS256',\n    'RS384',\n    'PS384',\n    'RS512',\n    'PS512',\n  ]\n  public static multicodecPrefix = 4613\n\n  public multicodecPrefix = RsaPublicJwk.multicodecPrefix\n  public supportedEncryptionKeyAgreementAlgorithms = RsaPublicJwk.supportdEncryptionKeyAgreementAlgorithms\n\n  public get supportedSignatureAlgorithms() {\n    const keyBits = TypedArrayEncoder.fromBase64(this.jwk.n).length * 8\n\n    // RSA needs minimum bit lengths for each algorithm\n    const minBits2048 = ['PS256', 'RS256'] satisfies KnownJwaSignatureAlgorithm[]\n    const minBits3072 = [...minBits2048, 'RS384', 'PS384'] satisfies KnownJwaSignatureAlgorithm[]\n    const minBits4096 = [...minBits3072, 'RS512', 'PS512'] satisfies KnownJwaSignatureAlgorithm[]\n\n    return keyBits >= 4096 ? minBits4096 : keyBits >= 3072 ? minBits3072 : keyBits >= 2048 ? minBits2048 : []\n  }\n\n  public constructor(public readonly jwk: KmsJwkPublicRsa) {}\n\n  public get publicKey() {\n    return {\n      kty: this.jwk.kty,\n      ...rsaPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for RSA\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec(): Uint8ArrayBuffer {\n    throw new KeyManagementError('multicodec not supported for RsaPublicJwk')\n  }\n\n  public static fromPublicKey(publicKey: { modulus: AnyUint8Array; exponent: AnyUint8Array }) {\n    return new RsaPublicJwk(rsaPublicKeyToPublicJwk(publicKey))\n  }\n\n  public static fromMulticodec(_multicodec: AnyUint8Array): RsaPublicJwk {\n    throw new KeyManagementError('fromMulticodec not supported for RsaPublicJwk')\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAa,eAAb,MAAa,aAAuD;CAelE,IAAW,+BAA+B;EACxC,MAAM,UAAU,kBAAkB,WAAW,KAAK,IAAI,EAAE,CAAC,SAAS;EAGlE,MAAM,cAAc,CAAC,SAAS,QAAQ;EACtC,MAAM,cAAc;GAAC,GAAG;GAAa;GAAS;GAAQ;EACtD,MAAM,cAAc;GAAC,GAAG;GAAa;GAAS;GAAQ;AAEtD,SAAO,WAAW,OAAO,cAAc,WAAW,OAAO,cAAc,WAAW,OAAO,cAAc,EAAE;;CAG3G,AAAO,YAAY,AAAgBA,KAAsB;EAAtB;OAd5B,mBAAmB,aAAa;OAChC,4CAA4C,aAAa;;CAehE,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,GAAG,wBAAwB,KAAK,IAAI;GACrC;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAA+B;AACxC,QAAM,IAAI,mBAAmB,4CAA4C;;CAG3E,OAAc,cAAc,WAAgE;AAC1F,SAAO,IAAI,aAAa,wBAAwB,UAAU,CAAC;;CAG7D,OAAc,eAAe,aAA0C;AACrE,QAAM,IAAI,mBAAmB,gDAAgD;;;aAlDjE,2CAA4E,EAAE;aAC9E,+BAA6D;CACzE;CACA;CACA;CACA;CACA;CACA;CACD;aACa,mBAAmB"}
+{"version":3,"file":"RsaPublicJwk.mjs","names":["jwk: KmsJwkPublicRsa"],"sources":["../../../../../../src/modules/kms/jwk/kty/rsa/RsaPublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport { TypedArrayEncoder } from '../../../../../utils'\nimport { KeyManagementError } from '../../../error/KeyManagementError'\nimport type { KnownJwaKeyAgreementAlgorithm, KnownJwaSignatureAlgorithm } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicRsa } from './rsaJwk'\nimport { rsaPublicJwkToPublicKey, rsaPublicKeyToPublicJwk } from './rsaPublicKey'\n\nexport class RsaPublicJwk implements PublicJwkType<KmsJwkPublicRsa> {\n  public static supportedEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[] = []\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [\n    'PS256',\n    'RS256',\n    'RS384',\n    'PS384',\n    'RS512',\n    'PS512',\n  ]\n  public static multicodecPrefix = 4613\n\n  public multicodecPrefix = RsaPublicJwk.multicodecPrefix\n  public supportedEncryptionKeyAgreementAlgorithms = RsaPublicJwk.supportedEncryptionKeyAgreementAlgorithms\n\n  public get supportedSignatureAlgorithms() {\n    const keyBits = TypedArrayEncoder.fromBase64(this.jwk.n).length * 8\n\n    // RSA needs minimum bit lengths for each algorithm\n    const minBits2048 = ['PS256', 'RS256'] satisfies KnownJwaSignatureAlgorithm[]\n    const minBits3072 = [...minBits2048, 'RS384', 'PS384'] satisfies KnownJwaSignatureAlgorithm[]\n    const minBits4096 = [...minBits3072, 'RS512', 'PS512'] satisfies KnownJwaSignatureAlgorithm[]\n\n    return keyBits >= 4096 ? minBits4096 : keyBits >= 3072 ? minBits3072 : keyBits >= 2048 ? minBits2048 : []\n  }\n\n  public constructor(public readonly jwk: KmsJwkPublicRsa) {}\n\n  public get publicKey() {\n    return {\n      kty: this.jwk.kty,\n      ...rsaPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for RSA\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec(): Uint8ArrayBuffer {\n    throw new KeyManagementError('multicodec not supported for RsaPublicJwk')\n  }\n\n  public static fromPublicKey(publicKey: { modulus: AnyUint8Array; exponent: AnyUint8Array }) {\n    return new RsaPublicJwk(rsaPublicKeyToPublicJwk(publicKey))\n  }\n\n  public static fromMulticodec(_multicodec: AnyUint8Array): RsaPublicJwk {\n    throw new KeyManagementError('fromMulticodec not supported for RsaPublicJwk')\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAa,eAAb,MAAa,aAAuD;CAelE,IAAW,+BAA+B;EACxC,MAAM,UAAU,kBAAkB,WAAW,KAAK,IAAI,EAAE,CAAC,SAAS;EAGlE,MAAM,cAAc,CAAC,SAAS,QAAQ;EACtC,MAAM,cAAc;GAAC,GAAG;GAAa;GAAS;GAAQ;EACtD,MAAM,cAAc;GAAC,GAAG;GAAa;GAAS;GAAQ;AAEtD,SAAO,WAAW,OAAO,cAAc,WAAW,OAAO,cAAc,WAAW,OAAO,cAAc,EAAE;;CAG3G,AAAO,YAAY,AAAgBA,KAAsB;EAAtB;OAd5B,mBAAmB,aAAa;OAChC,4CAA4C,aAAa;;CAehE,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,GAAG,wBAAwB,KAAK,IAAI;GACrC;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAA+B;AACxC,QAAM,IAAI,mBAAmB,4CAA4C;;CAG3E,OAAc,cAAc,WAAgE;AAC1F,SAAO,IAAI,aAAa,wBAAwB,UAAU,CAAC;;CAG7D,OAAc,eAAe,aAA0C;AACrE,QAAM,IAAI,mBAAmB,gDAAgD;;;aAlDjE,4CAA6E,EAAE;aAC/E,+BAA6D;CACzE;CACA;CACA;CACA;CACA;CACA;CACD;aACa,mBAAmB"}

package/build/utils/IntegrityVerifier.d.mts

@@ -0,0 +1,44 @@
+//#region src/utils/IntegrityVerifier.d.ts
+/**
+ * Verifies Subresource Integrity (SRI) metadata according to W3C specification.
+ *
+ * This class implements the verification logic for integrity metadata strings
+ * as defined in the W3C Subresource Integrity specification.
+ *
+ * @see https://www.w3.org/TR/SRI/
+ */
+declare class IntegrityVerifier {
+  /**
+   * Verifies the integrity of raw data against provided integrity metadata.
+   *
+   * @param data - The data to verify
+   * @param integrityMetadata - The integrity metadata string (e.g., "sha256-...")
+   * @throws {CredoError} if verification fails
+   */
+  static verifyIntegrity(data: Uint8Array, integrityMetadata: string): void;
+  /**
+   * Parses integrity metadata string into structured format.
+   *
+   * @param metadata - The integrity metadata string
+   * @returns Array of parsed metadata objects
+   */
+  private static parseIntegrityMetadata;
+  /**
+   * Returns the metadata for the strongest algorithm(s) in the set.
+   *
+   * @param metadataSet - Array of parsed metadata
+   * @returns Array containing only the strongest algorithm's metadata
+   */
+  private static getStrongestMetadata;
+  /**
+   * Applies the specified hash algorithm to the given bytes.
+   *
+   * @param bytes - The bytes to hash
+   * @param algorithm - The hash algorithm name
+   * @returns Base64-encoded hash value
+   */
+  private static applyAlgorithmToBytes;
+}
+//#endregion
+export { IntegrityVerifier };
+//# sourceMappingURL=IntegrityVerifier.d.mts.map

package/build/utils/IntegrityVerifier.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntegrityVerifier.d.mts","names":[],"sources":["../../src/utils/IntegrityVerifier.ts"],"sourcesContent":[],"mappings":";;;;AAaA;;;;;cAAa,iBAAA;;;;;;;;+BAQyB"}

package/build/utils/index.d.mts

@@ -2,6 +2,7 @@ import { Buffer } from "./buffer.mjs";
 import { asArray } from "./array.mjs";
 import { deepEquality, equalsIgnoreOrder, equalsWithOrder } from "./deepEquality.mjs";
 import { indyDidFromPublicKeyBase58, isDid } from "./did.mjs";
+import { IntegrityVerifier } from "./IntegrityVerifier.mjs";
 import { JsonEncoder } from "./JsonEncoder.mjs";
 import { JsonTransformer } from "./JsonTransformer.mjs";
 import { MessageValidator } from "./MessageValidator.mjs";

package/package.json

@@ -4,7 +4,7 @@
     ".": "./build/index.mjs",
     "./package.json": "./package.json"
   },
-  "version": "0.6.2-pr-2610-20260107224500",
+  "version": "0.6.2-pr-2610-20260108113505",
   "files": [
     "build"
   ],