jose 4.2.0 → 4.3.3

package/dist/node/esm/jwe/general/encrypt.js

@@ -5,20 +5,27 @@ import isDisjoint from '../../lib/is_disjoint.js';
 import encryptKeyManagement from '../../lib/encrypt_key_management.js';
 import { encode as base64url } from '../../runtime/base64url.js';
 import validateCrit from '../../lib/validate_crit.js';
-const recipientRef = new WeakMap();
 class IndividualRecipient {
+    constructor(enc, key, options) {
+        this.parent = enc;
+        this.key = key;
+        this.options = options;
+    }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        if (this.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        this.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _unprotectedHeader(value) {
-        recipientRef.get(this).unprotectedHeader = value;
+    addRecipient(...args) {
+        return this.parent.addRecipient(...args);
+    }
+    encrypt(...args) {
+        return this.parent.encrypt(...args);
     }
-    get _unprotectedHeader() {
-        return recipientRef.get(this).unprotectedHeader;
+    done() {
+        return this.parent;
     }
 }
 export class GeneralEncrypt {
@@ -27,8 +34,7 @@ export class GeneralEncrypt {
         this._plaintext = plaintext;
     }
     addRecipient(key, options) {
-        const recipient = new IndividualRecipient();
-        recipientRef.set(recipient, { key, options: { crit: options === null || options === void 0 ? void 0 : options.crit } });
+        const recipient = new IndividualRecipient(this, key, { crit: options === null || options === void 0 ? void 0 : options.crit });
         this._recipients.push(recipient);
         return recipient;
     }
@@ -51,19 +57,19 @@ export class GeneralEncrypt {
         return this;
     }
     async encrypt(options) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!this._recipients.length) {
             throw new JWEInvalid('at least one recipient must be added');
         }
         options = { deflateRaw: options === null || options === void 0 ? void 0 : options.deflateRaw };
         if (this._recipients.length === 1) {
-            const { unprotectedHeader, options: recipientOpts, key, } = recipientRef.get(this._recipients[0]);
+            const [recipient] = this._recipients;
             const flattened = await new FlattenedEncrypt(this._plaintext)
                 .setAdditionalAuthenticatedData(this._aad)
                 .setProtectedHeader(this._protectedHeader)
                 .setSharedUnprotectedHeader(this._unprotectedHeader)
-                .setUnprotectedHeader(unprotectedHeader)
-                .encrypt(key, { ...recipientOpts, ...options });
+                .setUnprotectedHeader(recipient.unprotectedHeader)
+                .encrypt(recipient.key, { ...recipient.options, ...options });
             let jwe = {
                 ciphertext: flattened.ciphertext,
                 iv: flattened.iv,
@@ -85,14 +91,13 @@ export class GeneralEncrypt {
         let enc;
         for (let i = 0; i < this._recipients.length; i++) {
             const recipient = this._recipients[i];
-            const { unprotectedHeader, options: recipientOpts } = recipientRef.get(recipient);
-            if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, unprotectedHeader)) {
+            if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, recipient.unprotectedHeader)) {
                 throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
             }
             const joseHeader = {
                 ...this._protectedHeader,
                 ...this._unprotectedHeader,
-                ...unprotectedHeader,
+                ...recipient.unprotectedHeader,
             };
             const { alg } = joseHeader;
             if (typeof alg !== 'string' || !alg) {
@@ -110,7 +115,7 @@ export class GeneralEncrypt {
             else if (enc !== joseHeader.enc) {
                 throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
             }
-            validateCrit(JWEInvalid, new Map(), recipientOpts === null || recipientOpts === void 0 ? void 0 : recipientOpts.crit, this._protectedHeader, joseHeader);
+            validateCrit(JWEInvalid, new Map(), recipient.options.crit, this._protectedHeader, joseHeader);
             if (joseHeader.zip !== undefined) {
                 if (!this._protectedHeader || !this._protectedHeader.zip) {
                     throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
@@ -128,15 +133,18 @@ export class GeneralEncrypt {
             const recipient = this._recipients[i];
             const target = {};
             jwe.recipients.push(target);
-            const { unprotectedHeader, options: recipientOpts, key } = recipientRef.get(recipient);
             if (i === 0) {
                 const flattened = await new FlattenedEncrypt(this._plaintext)
                     .setAdditionalAuthenticatedData(this._aad)
                     .setContentEncryptionKey(cek)
                     .setProtectedHeader(this._protectedHeader)
                     .setSharedUnprotectedHeader(this._unprotectedHeader)
-                    .setUnprotectedHeader(unprotectedHeader)
-                    .encrypt(key, { ...recipientOpts, ...options, [unprotected]: true });
+                    .setUnprotectedHeader(recipient.unprotectedHeader)
+                    .encrypt(recipient.key, {
+                    ...recipient.options,
+                    ...options,
+                    [unprotected]: true,
+                });
                 jwe.ciphertext = flattened.ciphertext;
                 jwe.iv = flattened.iv;
                 jwe.tag = flattened.tag;
@@ -151,10 +159,12 @@ export class GeneralEncrypt {
                     target.header = flattened.header;
                 continue;
             }
-            const { encryptedKey, parameters } = await encryptKeyManagement((unprotectedHeader === null || unprotectedHeader === void 0 ? void 0 : unprotectedHeader.alg) || ((_a = this._protectedHeader) === null || _a === void 0 ? void 0 : _a.alg) || ((_b = this._unprotectedHeader) === null || _b === void 0 ? void 0 : _b.alg), enc, key, cek);
+            const { encryptedKey, parameters } = await encryptKeyManagement(((_a = recipient.unprotectedHeader) === null || _a === void 0 ? void 0 : _a.alg) ||
+                ((_b = this._protectedHeader) === null || _b === void 0 ? void 0 : _b.alg) ||
+                ((_c = this._unprotectedHeader) === null || _c === void 0 ? void 0 : _c.alg), enc, recipient.key, cek);
             target.encrypted_key = base64url(encryptedKey);
-            if (unprotectedHeader || parameters)
-                target.header = { ...unprotectedHeader, ...parameters };
+            if (recipient.unprotectedHeader || parameters)
+                target.header = { ...recipient.unprotectedHeader, ...parameters };
         }
         return jwe;
     }

package/dist/node/esm/jwks/remote.js

@@ -37,17 +37,21 @@ class RemoteJWKSet {
         }
         return Date.now() < this._cooldownStarted + this._cooldownDuration;
     }
-    async getKey(protectedHeader) {
+    async getKey(protectedHeader, token) {
+        const joseHeader = {
+            ...protectedHeader,
+            ...token.header,
+        };
         if (!this._jwks) {
             await this.reload();
         }
         const candidates = this._jwks.keys.filter((jwk) => {
-            let candidate = jwk.kty === getKtyFromAlg(protectedHeader.alg);
-            if (candidate && typeof protectedHeader.kid === 'string') {
-                candidate = protectedHeader.kid === jwk.kid;
+            let candidate = jwk.kty === getKtyFromAlg(joseHeader.alg);
+            if (candidate && typeof joseHeader.kid === 'string') {
+                candidate = joseHeader.kid === jwk.kid;
             }
             if (candidate && typeof jwk.alg === 'string') {
-                candidate = protectedHeader.alg === jwk.alg;
+                candidate = joseHeader.alg === jwk.alg;
             }
             if (candidate && typeof jwk.use === 'string') {
                 candidate = jwk.use === 'sig';
@@ -55,11 +59,11 @@ class RemoteJWKSet {
             if (candidate && Array.isArray(jwk.key_ops)) {
                 candidate = jwk.key_ops.includes('verify');
             }
-            if (candidate && protectedHeader.alg === 'EdDSA') {
+            if (candidate && joseHeader.alg === 'EdDSA') {
                 candidate = jwk.crv === 'Ed25519' || jwk.crv === 'Ed448';
             }
             if (candidate) {
-                switch (protectedHeader.alg) {
+                switch (joseHeader.alg) {
                     case 'ES256':
                         candidate = jwk.crv === 'P-256';
                         break;
@@ -81,7 +85,7 @@ class RemoteJWKSet {
         if (length === 0) {
             if (this.coolingDown() === false) {
                 await this.reload();
-                return this.getKey(protectedHeader);
+                return this.getKey(protectedHeader, token);
             }
             throw new JWKSNoMatchingKey();
         }
@@ -89,14 +93,14 @@ class RemoteJWKSet {
             throw new JWKSMultipleMatchingKeys();
         }
         const cached = this._cached.get(jwk) || this._cached.set(jwk, {}).get(jwk);
-        if (cached[protectedHeader.alg] === undefined) {
-            const keyObject = await importJWK({ ...jwk, ext: true }, protectedHeader.alg);
+        if (cached[joseHeader.alg] === undefined) {
+            const keyObject = await importJWK({ ...jwk, ext: true }, joseHeader.alg);
             if (keyObject instanceof Uint8Array || keyObject.type !== 'public') {
                 throw new JWKSInvalid('JSON Web Key Set members must be public keys');
             }
-            cached[protectedHeader.alg] = keyObject;
+            cached[joseHeader.alg] = keyObject;
         }
-        return cached[protectedHeader.alg];
+        return cached[joseHeader.alg];
     }
     async reload() {
         if (!this._pendingFetch) {

package/dist/node/esm/jws/general/sign.js

@@ -1,32 +1,33 @@
 import { FlattenedSign } from '../flattened/sign.js';
 import { JWSInvalid } from '../../util/errors.js';
-const signatureRef = new WeakMap();
 class IndividualSignature {
+    constructor(sig, key, options) {
+        this.parent = sig;
+        this.key = key;
+        this.options = options;
+    }
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        if (this.protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        this.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        if (this.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        this.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _protectedHeader(value) {
-        signatureRef.get(this).protectedHeader = value;
-    }
-    get _protectedHeader() {
-        return signatureRef.get(this).protectedHeader;
+    addSignature(...args) {
+        return this.parent.addSignature(...args);
     }
-    set _unprotectedHeader(value) {
-        signatureRef.get(this).unprotectedHeader = value;
+    sign(...args) {
+        return this.parent.sign(...args);
     }
-    get _unprotectedHeader() {
-        return signatureRef.get(this).unprotectedHeader;
+    done() {
+        return this.parent;
     }
 }
 export class GeneralSign {
@@ -35,8 +36,7 @@ export class GeneralSign {
         this._payload = payload;
     }
     addSignature(key, options) {
-        const signature = new IndividualSignature();
-        signatureRef.set(signature, { key, options });
+        const signature = new IndividualSignature(this, key, options);
         this._signatures.push(signature);
         return signature;
     }
@@ -48,23 +48,19 @@ export class GeneralSign {
             signatures: [],
             payload: '',
         };
-        let payloads = new Set();
-        await Promise.all(this._signatures.map(async (sig) => {
-            const { protectedHeader, unprotectedHeader, options, key } = signatureRef.get(sig);
+        for (let i = 0; i < this._signatures.length; i++) {
+            const signature = this._signatures[i];
             const flattened = new FlattenedSign(this._payload);
-            if (protectedHeader) {
-                flattened.setProtectedHeader(protectedHeader);
+            flattened.setProtectedHeader(signature.protectedHeader);
+            flattened.setUnprotectedHeader(signature.unprotectedHeader);
+            const { payload, ...rest } = await flattened.sign(signature.key, signature.options);
+            if (i === 0) {
+                jws.payload = payload;
             }
-            if (unprotectedHeader) {
-                flattened.setUnprotectedHeader(unprotectedHeader);
+            else if (jws.payload !== payload) {
+                throw new JWSInvalid('inconsistent use of JWS Unencoded Payload Option (RFC7797)');
             }
-            const { payload, ...rest } = await flattened.sign(key, options);
-            payloads.add(payload);
-            jws.payload = payload;
             jws.signatures.push(rest);
-        }));
-        if (payloads.size !== 1) {
-            throw new JWSInvalid('inconsistent use of JWS Unencoded Payload Option (RFC7797)');
         }
         return jws;
     }

package/dist/node/esm/lib/cek.js

@@ -2,18 +2,17 @@ import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
 export function bitLength(alg) {
     switch (alg) {
-        case 'A128CBC-HS256':
-            return 256;
-        case 'A192CBC-HS384':
-            return 384;
-        case 'A256CBC-HS512':
-            return 512;
         case 'A128GCM':
             return 128;
         case 'A192GCM':
             return 192;
         case 'A256GCM':
+        case 'A128CBC-HS256':
             return 256;
+        case 'A192CBC-HS384':
+            return 384;
+        case 'A256CBC-HS512':
+            return 512;
         default:
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

package/dist/node/esm/lib/decrypt_key_management.js

@@ -40,7 +40,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
                     throw new JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
                 partyVInfo = base64url(joseHeader.apv);
             }
-            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLength(joseHeader.enc), partyUInfo, partyVInfo);
+            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? cekLength(joseHeader.enc) : parseInt(alg.substr(-5, 3), 10), partyUInfo, partyVInfo);
             if (alg === 'ECDH-ES')
                 return sharedSecret;
             if (encryptedKey === undefined)

package/dist/node/esm/lib/encrypt_key_management.js

@@ -29,7 +29,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             let { epk: ephemeralKey } = providedParameters;
             ephemeralKey || (ephemeralKey = await ECDH.generateEpk(key));
             const { x, y, crv, kty } = await exportJWK(ephemeralKey);
-            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLength(enc), apu, apv);
+            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.substr(-5, 3), 10), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)
                 parameters.apu = base64url(apu);

package/dist/node/esm/lib/iv.js

@@ -2,24 +2,17 @@ import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
 export function bitLength(alg) {
     switch (alg) {
-        case 'A128CBC-HS256':
-            return 128;
         case 'A128GCM':
-            return 96;
         case 'A128GCMKW':
-            return 96;
-        case 'A192CBC-HS384':
-            return 128;
         case 'A192GCM':
-            return 96;
         case 'A192GCMKW':
-            return 96;
-        case 'A256CBC-HS512':
-            return 128;
         case 'A256GCM':
-            return 96;
         case 'A256GCMKW':
             return 96;
+        case 'A128CBC-HS256':
+        case 'A192CBC-HS384':
+        case 'A256CBC-HS512':
+            return 128;
         default:
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

package/dist/node/esm/runtime/aeskw.js

@@ -8,6 +8,7 @@ import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import supported from './ciphers.js';
+import { types } from './is_key_like.js';
 function checkKeySize(key, alg) {
     if (key.symmetricKeySize << 3 !== parseInt(alg.substr(1, 3), 10)) {
         throw new TypeError(`Invalid key size for alg: ${alg}`);
@@ -24,9 +25,9 @@ function ensureKeyObject(key, alg, usage) {
         checkEncCryptoKey(key, alg, usage);
         return KeyObject.from(key);
     }
-    throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }
-export const wrap = async (alg, key, cek) => {
+export const wrap = (alg, key, cek) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
     if (!supported(algorithm)) {
@@ -37,7 +38,7 @@ export const wrap = async (alg, key, cek) => {
     const cipher = createCipheriv(algorithm, keyObject, Buffer.alloc(8, 0xa6));
     return concat(cipher.update(cek), cipher.final());
 };
-export const unwrap = async (alg, key, encryptedKey) => {
+export const unwrap = (alg, key, encryptedKey) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
     if (!supported(algorithm)) {

package/dist/node/esm/runtime/asn1.js

@@ -3,6 +3,7 @@ import { Buffer } from 'buffer';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 const genericExport = (keyType, keyFormat, key) => {
     let keyObject;
     if (isCryptoKey(key)) {
@@ -15,7 +16,7 @@ const genericExport = (keyType, keyFormat, key) => {
         keyObject = key;
     }
     else {
-        throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     if (keyObject.type !== keyType) {
         throw new TypeError(`key is not a ${keyType} key`);

package/dist/node/esm/runtime/decrypt.js

@@ -10,7 +10,8 @@ import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import supported from './ciphers.js';
-async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+import { types } from './is_key_like.js';
+function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     if (isKeyObject(cek)) {
         cek = cek.export();
@@ -44,7 +45,7 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     return plaintext;
 }
-async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     const algorithm = `aes-${keySize}-gcm`;
     if (!supported(algorithm)) {
@@ -64,7 +65,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new JWEDecryptionFailed();
     }
 }
-const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
+const decrypt = (enc, cek, ciphertext, iv, tag, aad) => {
     let key;
     if (isCryptoKey(cek)) {
         checkEncCryptoKey(cek, enc, 'decrypt');
@@ -74,7 +75,7 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
         key = cek;
     }
     else {
-        throw new TypeError(invalidKeyInput(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
     }
     checkCekLength(enc, key);
     checkIvLength(enc, iv);

package/dist/node/esm/runtime/ecdhes.js

@@ -8,8 +8,9 @@ import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 const generateKeyPair = promisify(generateKeyPairCb);
-export const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
+export const deriveKey = (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     let publicKey;
     if (isCryptoKey(publicKee)) {
         checkEncCryptoKey(publicKee, 'ECDH-ES');
@@ -19,7 +20,7 @@ export const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu
         publicKey = publicKee;
     }
     else {
-        throw new TypeError(invalidKeyInput(publicKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(publicKee, ...types));
     }
     let privateKey;
     if (isCryptoKey(privateKee)) {
@@ -30,7 +31,7 @@ export const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu
         privateKey = privateKee;
     }
     else {
-        throw new TypeError(invalidKeyInput(privateKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(privateKee, ...types));
     }
     const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
     const sharedSecret = diffieHellman({ privateKey, publicKey });
@@ -45,7 +46,7 @@ export const generateEpk = async (kee) => {
         key = kee;
     }
     else {
-        throw new TypeError(invalidKeyInput(kee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(kee, ...types));
     }
     switch (key.asymmetricKeyType) {
         case 'x25519':

package/dist/node/esm/runtime/encrypt.js

@@ -9,7 +9,8 @@ import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { JOSENotSupported } from '../util/errors.js';
 import supported from './ciphers.js';
-async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
+import { types } from './is_key_like.js';
+function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     if (isKeyObject(cek)) {
         cek = cek.export();
@@ -26,7 +27,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const tag = cbcTag(aad, iv, ciphertext, macSize, macKey, keySize);
     return { ciphertext, tag };
 }
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
+function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     const algorithm = `aes-${keySize}-gcm`;
     if (!supported(algorithm)) {
@@ -41,7 +42,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const tag = cipher.getAuthTag();
     return { ciphertext, tag };
 }
-const encrypt = async (enc, plaintext, cek, iv, aad) => {
+const encrypt = (enc, plaintext, cek, iv, aad) => {
     let key;
     if (isCryptoKey(cek)) {
         checkEncCryptoKey(cek, enc, 'encrypt');
@@ -51,7 +52,7 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
         key = cek;
     }
     else {
-        throw new TypeError(invalidKeyInput(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
     }
     checkCekLength(enc, key);
     checkIvLength(enc, iv);

package/dist/node/esm/runtime/get_named_curve.js

@@ -4,6 +4,7 @@ import { JOSENotSupported } from '../util/errors.js';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 const p256 = Buffer.from([42, 134, 72, 206, 61, 3, 1, 7]);
 const p384 = Buffer.from([43, 129, 4, 0, 34]);
 const p521 = Buffer.from([43, 129, 4, 0, 35]);
@@ -33,7 +34,7 @@ const getNamedCurve = (kee, raw) => {
         key = kee;
     }
     else {
-        throw new TypeError(invalidKeyInput(kee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(kee, ...types));
     }
     if (key.type === 'secret') {
         throw new TypeError('only "private" or "public" type keys can be used for this operation');

package/dist/node/esm/runtime/get_sign_verify_key.js

@@ -3,10 +3,11 @@ import { isCryptoKey } from './webcrypto.js';
 import { checkSigCryptoKey } from '../lib/crypto_key.js';
 import getSecretKey from './secret_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 export default function getSignVerifyKey(alg, key, usage) {
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {
-            throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey'));
+            throw new TypeError(invalidKeyInput(key, ...types));
         }
         return getSecretKey(key);
     }
@@ -17,5 +18,5 @@ export default function getSignVerifyKey(alg, key, usage) {
         checkSigCryptoKey(key, alg, usage);
         return KeyObject.from(key);
     }
-    throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }

package/dist/node/esm/runtime/key_to_jwk.js

@@ -6,6 +6,7 @@ import getNamedCurve from './get_named_curve.js';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 const [major, minor] = process.version
     .substr(1)
     .split('.')
@@ -29,7 +30,7 @@ const keyToJWK = (key) => {
         };
     }
     else {
-        throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
     }
     if (jwkExportSupported) {
         return keyObject.export({ format: 'jwk' });

package/dist/node/esm/runtime/pbes2kw.js

@@ -9,6 +9,7 @@ import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 const pbkdf2 = promisify(pbkdf2cb);
 function getPassword(key, alg) {
     if (isKeyObject(key)) {
@@ -21,7 +22,7 @@ function getPassword(key, alg) {
         checkEncCryptoKey(key, alg, 'deriveBits', 'deriveKey');
         return KeyObject.from(key).export();
     }
-    throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }
 export const encrypt = async (alg, key, cek, p2c = Math.floor(Math.random() * 2049) + 2048, p2s = random(new Uint8Array(16))) => {
     checkP2s(p2s);

package/dist/node/esm/runtime/rsaes.js

@@ -4,6 +4,7 @@ import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 const checkKey = (key, alg) => {
     if (key.asymmetricKeyType !== 'rsa') {
         throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
@@ -45,16 +46,16 @@ function ensureKeyObject(key, alg, ...usages) {
         checkEncCryptoKey(key, alg, ...usages);
         return KeyObject.from(key);
     }
-    throw new TypeError(invalidKeyInput(key, 'KeyObject', 'CryptoKey'));
+    throw new TypeError(invalidKeyInput(key, ...types));
 }
-export const encrypt = async (alg, key, cek) => {
+export const encrypt = (alg, key, cek) => {
     const padding = resolvePadding(alg);
     const oaepHash = resolveOaepHash(alg);
     const keyObject = ensureKeyObject(key, alg, 'wrapKey', 'encrypt');
     checkKey(keyObject, alg);
     return publicEncrypt({ key: keyObject, oaepHash, padding }, cek);
 };
-export const decrypt = async (alg, key, encryptedKey) => {
+export const decrypt = (alg, key, encryptedKey) => {
     const padding = resolvePadding(alg);
     const oaepHash = resolveOaepHash(alg);
     const keyObject = ensureKeyObject(key, alg, 'unwrapKey', 'decrypt');

package/dist/types/index.d.ts

@@ -42,4 +42,4 @@ export type { GenerateKeyPairResult, GenerateKeyPairOptions } from './key/genera
 export { generateSecret } from './key/generate_secret';
 export type { GenerateSecretOptions } from './key/generate_secret';
 export * as base64url from './util/base64url';
-export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, DeflateFunction, InflateFunction, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, } from './types';
+export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, DeflateFunction, InflateFunction, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, CompactJWEHeaderParameters, CompactJWSHeaderParameters, JWTHeaderParameters, } from './types';

package/dist/types/jwe/compact/decrypt.d.ts

@@ -1,5 +1,5 @@
-import type { KeyLike, DecryptOptions, JWEHeaderParameters, GetKeyFunction, FlattenedJWE, CompactDecryptResult, ResolvedKey } from '../../types';
-export interface CompactDecryptGetKey extends GetKeyFunction<JWEHeaderParameters, FlattenedJWE> {
+import type { KeyLike, DecryptOptions, CompactJWEHeaderParameters, GetKeyFunction, FlattenedJWE, CompactDecryptResult, ResolvedKey } from '../../types';
+export interface CompactDecryptGetKey extends GetKeyFunction<CompactJWEHeaderParameters, FlattenedJWE> {
 }
 export declare function compactDecrypt(jwe: string | Uint8Array, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<CompactDecryptResult>;
 export declare function compactDecrypt(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: DecryptOptions): Promise<CompactDecryptResult & ResolvedKey>;