jose 4.2.0 → 4.2.1

package/dist/browser/jwe/general/encrypt.js

@@ -8,18 +8,13 @@ import validateCrit from '../../lib/validate_crit.js';
 const recipientRef = new WeakMap();
 class IndividualRecipient {
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = recipientRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _unprotectedHeader(value) {
-        recipientRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return recipientRef.get(this).unprotectedHeader;
-    }
 }
 export class GeneralEncrypt {
     constructor(plaintext) {

package/dist/browser/jws/general/sign.js

@@ -3,31 +3,21 @@ import { JWSInvalid } from '../../util/errors.js';
 const signatureRef = new WeakMap();
 class IndividualSignature {
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        ref.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _protectedHeader(value) {
-        signatureRef.get(this).protectedHeader = value;
-    }
-    get _protectedHeader() {
-        return signatureRef.get(this).protectedHeader;
-    }
-    set _unprotectedHeader(value) {
-        signatureRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return signatureRef.get(this).unprotectedHeader;
-    }
 }
 export class GeneralSign {
     constructor(payload) {

package/dist/browser/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/browser/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/browser/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/browser/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/browser/runtime/aeskw.js

@@ -2,6 +2,7 @@ import bogusWebCrypto from './bogus.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 function checkKeySize(key, alg) {
     if (key.algorithm.length !== parseInt(alg.substr(1, 3), 10)) {
         throw new TypeError(`Invalid key size for alg: ${alg}`);
@@ -15,7 +16,7 @@ function getCryptoKey(key, alg, usage) {
     if (key instanceof Uint8Array) {
         return crypto.subtle.importKey('raw', key, 'AES-KW', true, [usage]);
     }
-    throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }
 export const wrap = async (alg, key, cek) => {
     const cryptoKey = await getCryptoKey(key, alg, 'wrapKey');

package/dist/browser/runtime/asn1.js

@@ -4,9 +4,10 @@ import invalidKeyInput from '../lib/invalid_key_input.js';
 import { encodeBase64 } from './base64url.js';
 import formatPEM from '../lib/format_pem.js';
 import { JOSENotSupported } from '../util/errors.js';
+import { types } from './is_key_like.js';
 const genericExport = async (keyType, keyFormat, key) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     if (!key.extractable) {
         throw new TypeError('CryptoKey is not extractable');

package/dist/browser/runtime/decrypt.js

@@ -6,6 +6,7 @@ import { JOSENotSupported, JWEDecryptionFailed } from '../util/errors.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -61,7 +62,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 }
 const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
     }
     checkIvLength(enc, iv);
     switch (enc) {

package/dist/browser/runtime/ecdhes.js

@@ -3,13 +3,14 @@ import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import digest from './digest.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 export const deriveKey = async (publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     if (!isCryptoKey(publicKey)) {
-        throw new TypeError(invalidKeyInput(publicKey, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(publicKey, ...types));
     }
     checkEncCryptoKey(publicKey, 'ECDH-ES');
     if (!isCryptoKey(privateKey)) {
-        throw new TypeError(invalidKeyInput(privateKey, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(privateKey, ...types));
     }
     checkEncCryptoKey(privateKey, 'ECDH-ES', 'deriveBits', 'deriveKey');
     const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
@@ -25,13 +26,13 @@ export const deriveKey = async (publicKey, privateKey, algorithm, keyLength, apu
 };
 export const generateEpk = async (key) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     return (await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: key.algorithm.namedCurve }, true, ['deriveBits'])).privateKey;
 };
 export const ecdhAllowed = (key) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     return ['P-256', 'P-384', 'P-521'].includes(key.algorithm.namedCurve);
 };

package/dist/browser/runtime/encrypt.js

@@ -5,6 +5,7 @@ import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { JOSENotSupported } from '../util/errors.js';
+import { types } from './is_key_like.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -44,7 +45,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
 }
 const encrypt = async (enc, plaintext, cek, iv, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
     }
     checkIvLength(enc, iv);
     switch (enc) {

package/dist/browser/runtime/get_sign_verify_key.js

@@ -1,6 +1,7 @@
 import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkSigCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 export default function getCryptoKey(alg, key, usage) {
     if (isCryptoKey(key)) {
         checkSigCryptoKey(key, alg, usage);
@@ -8,9 +9,9 @@ export default function getCryptoKey(alg, key, usage) {
     }
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {
-            throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+            throw new TypeError(invalidKeyInput(key, ...types));
         }
         return crypto.subtle.importKey('raw', key, { hash: `SHA-${alg.substr(-3)}`, name: 'HMAC' }, false, [usage]);
     }
-    throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }

package/dist/browser/runtime/key_to_jwk.js

@@ -1,6 +1,7 @@
 import crypto, { isCryptoKey } from './webcrypto.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { encode as base64url } from './base64url.js';
+import { types } from './is_key_like.js';
 const keyToJWK = async (key) => {
     if (key instanceof Uint8Array) {
         return {
@@ -9,7 +10,7 @@ const keyToJWK = async (key) => {
         };
     }
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
     }
     if (!key.extractable) {
         throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');

package/dist/browser/runtime/pbes2kw.js

@@ -6,6 +6,7 @@ import checkP2s from '../lib/check_p2s.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 function getCryptoKey(key, alg) {
     if (key instanceof Uint8Array) {
         return crypto.subtle.importKey('raw', key, 'PBKDF2', false, ['deriveBits']);
@@ -14,7 +15,7 @@ function getCryptoKey(key, alg) {
         checkEncCryptoKey(key, alg, 'deriveBits', 'deriveKey');
         return key;
     }
-    throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }
 async function deriveKey(p2s, alg, p2c, key) {
     checkP2s(p2s);

package/dist/browser/runtime/rsaes.js

@@ -4,9 +4,10 @@ import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import checkKeyLength from './check_key_length.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 export const encrypt = async (alg, key, cek) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     checkEncCryptoKey(key, alg, 'encrypt', 'wrapKey');
     checkKeyLength(alg, key);
@@ -21,7 +22,7 @@ export const encrypt = async (alg, key, cek) => {
 };
 export const decrypt = async (alg, key, encryptedKey) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     checkEncCryptoKey(key, alg, 'decrypt', 'unwrapKey');
     checkKeyLength(alg, key);

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

@@ -11,18 +11,13 @@ const validate_crit_js_1 = require("../../lib/validate_crit.js");
 const recipientRef = new WeakMap();
 class IndividualRecipient {
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = recipientRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _unprotectedHeader(value) {
-        recipientRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return recipientRef.get(this).unprotectedHeader;
-    }
 }
 class GeneralEncrypt {
     constructor(plaintext) {

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

@@ -6,31 +6,21 @@ const errors_js_1 = require("../../util/errors.js");
 const signatureRef = new WeakMap();
 class IndividualSignature {
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        ref.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _protectedHeader(value) {
-        signatureRef.get(this).protectedHeader = value;
-    }
-    get _protectedHeader() {
-        return signatureRef.get(this).protectedHeader;
-    }
-    set _unprotectedHeader(value) {
-        signatureRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return signatureRef.get(this).unprotectedHeader;
-    }
 }
 class GeneralSign {
     constructor(payload) {

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

@@ -5,18 +5,17 @@ const errors_js_1 = require("../util/errors.js");
 const random_js_1 = require("../runtime/random.js");
 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 errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

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

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

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

@@ -31,7 +31,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 (0, export_js_1.exportJWK)(ephemeralKey);
-            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, parseInt(alg.substr(-5, 3), 10) || (0, cek_js_1.bitLength)(enc), apu, apv);
+            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? (0, cek_js_1.bitLength)(enc) : parseInt(alg.substr(-5, 3), 10), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)
                 parameters.apu = (0, base64url_js_1.encode)(apu);

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

@@ -5,24 +5,17 @@ const errors_js_1 = require("../util/errors.js");
 const random_js_1 = require("../runtime/random.js");
 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 errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

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

@@ -11,6 +11,7 @@ const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
+const is_key_like_js_1 = require("./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}`);
@@ -27,9 +28,9 @@ function ensureKeyObject(key, alg, usage) {
         (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, usage);
         return crypto_1.KeyObject.from(key);
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
 }
-const wrap = async (alg, key, cek) => {
+const wrap = (alg, key, cek) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
     if (!(0, ciphers_js_1.default)(algorithm)) {
@@ -41,7 +42,7 @@ const wrap = async (alg, key, cek) => {
     return (0, buffer_utils_js_1.concat)(cipher.update(cek), cipher.final());
 };
 exports.wrap = wrap;
-const unwrap = async (alg, key, encryptedKey) => {
+const unwrap = (alg, key, encryptedKey) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
     if (!(0, ciphers_js_1.default)(algorithm)) {

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

@@ -6,6 +6,7 @@ const buffer_1 = require("buffer");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const genericExport = (keyType, keyFormat, key) => {
     let keyObject;
     if ((0, webcrypto_js_1.isCryptoKey)(key)) {
@@ -18,7 +19,7 @@ const genericExport = (keyType, keyFormat, key) => {
         keyObject = key;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
     }
     if (keyObject.type !== keyType) {
         throw new TypeError(`key is not a ${keyType} key`);

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

@@ -12,7 +12,8 @@ const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
-async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+const is_key_like_js_1 = require("./is_key_like.js");
+function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     if ((0, is_key_object_js_1.default)(cek)) {
         cek = cek.export();
@@ -46,7 +47,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 (!(0, ciphers_js_1.default)(algorithm)) {
@@ -66,7 +67,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new errors_js_1.JWEDecryptionFailed();
     }
 }
-const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
+const decrypt = (enc, cek, ciphertext, iv, tag, aad) => {
     let key;
     if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
         (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, 'decrypt');
@@ -76,7 +77,7 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
         key = cek;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     (0, check_cek_length_js_1.default)(enc, key);
     (0, check_iv_length_js_1.default)(enc, iv);

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

@@ -11,8 +11,9 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const generateKeyPair = (0, util_1.promisify)(crypto_1.generateKeyPair);
-const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
+const deriveKey = (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     let publicKey;
     if ((0, webcrypto_js_1.isCryptoKey)(publicKee)) {
         (0, crypto_key_js_1.checkEncCryptoKey)(publicKee, 'ECDH-ES');
@@ -22,7 +23,7 @@ const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new
         publicKey = publicKee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, ...is_key_like_js_1.types));
     }
     let privateKey;
     if ((0, webcrypto_js_1.isCryptoKey)(privateKee)) {
@@ -33,7 +34,7 @@ const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new
         privateKey = privateKee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, ...is_key_like_js_1.types));
     }
     const value = (0, buffer_utils_js_1.concat)((0, buffer_utils_js_1.lengthAndInput)(buffer_utils_js_1.encoder.encode(algorithm)), (0, buffer_utils_js_1.lengthAndInput)(apu), (0, buffer_utils_js_1.lengthAndInput)(apv), (0, buffer_utils_js_1.uint32be)(keyLength));
     const sharedSecret = (0, crypto_1.diffieHellman)({ privateKey, publicKey });
@@ -49,7 +50,7 @@ const generateEpk = async (kee) => {
         key = kee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(kee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
     }
     switch (key.asymmetricKeyType) {
         case 'x25519':

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

@@ -11,7 +11,8 @@ const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const errors_js_1 = require("../util/errors.js");
 const ciphers_js_1 = require("./ciphers.js");
-async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
+const is_key_like_js_1 = require("./is_key_like.js");
+function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     if ((0, is_key_object_js_1.default)(cek)) {
         cek = cek.export();
@@ -28,7 +29,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const tag = (0, cbc_tag_js_1.default)(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 (!(0, ciphers_js_1.default)(algorithm)) {
@@ -43,7 +44,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 ((0, webcrypto_js_1.isCryptoKey)(cek)) {
         (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, 'encrypt');
@@ -53,7 +54,7 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
         key = cek;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     (0, check_cek_length_js_1.default)(enc, key);
     (0, check_iv_length_js_1.default)(enc, iv);

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

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

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

@@ -5,10 +5,11 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const secret_key_js_1 = require("./secret_key.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 function getSignVerifyKey(alg, key, usage) {
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {
-            throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+            throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
         }
         return (0, secret_key_js_1.default)(key);
     }
@@ -19,6 +20,6 @@ function getSignVerifyKey(alg, key, usage) {
         (0, crypto_key_js_1.checkSigCryptoKey)(key, alg, usage);
         return crypto_1.KeyObject.from(key);
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
 }
 exports.default = getSignVerifyKey;

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

@@ -8,6 +8,7 @@ const get_named_curve_js_1 = require("./get_named_curve.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const [major, minor] = process.version
     .substr(1)
     .split('.')
@@ -31,7 +32,7 @@ const keyToJWK = (key) => {
         };
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     if (jwkExportSupported) {
         return keyObject.export({ format: 'jwk' });

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

@@ -12,6 +12,7 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const pbkdf2 = (0, util_1.promisify)(crypto_1.pbkdf2);
 function getPassword(key, alg) {
     if ((0, is_key_object_js_1.default)(key)) {
@@ -24,7 +25,7 @@ function getPassword(key, alg) {
         (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, 'deriveBits', 'deriveKey');
         return crypto_1.KeyObject.from(key).export();
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
 }
 const encrypt = async (alg, key, cek, p2c = Math.floor(Math.random() * 2049) + 2048, p2s = (0, random_js_1.default)(new Uint8Array(16))) => {
     (0, check_p2s_js_1.default)(p2s);

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

@@ -7,6 +7,7 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./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');
@@ -48,9 +49,9 @@ function ensureKeyObject(key, alg, ...usages) {
         (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, ...usages);
         return crypto_1.KeyObject.from(key);
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
 }
-const encrypt = async (alg, key, cek) => {
+const encrypt = (alg, key, cek) => {
     const padding = resolvePadding(alg);
     const oaepHash = resolveOaepHash(alg);
     const keyObject = ensureKeyObject(key, alg, 'wrapKey', 'encrypt');
@@ -58,7 +59,7 @@ const encrypt = async (alg, key, cek) => {
     return (0, crypto_1.publicEncrypt)({ key: keyObject, oaepHash, padding }, cek);
 };
 exports.encrypt = encrypt;
-const decrypt = async (alg, key, encryptedKey) => {
+const decrypt = (alg, key, encryptedKey) => {
     const padding = resolvePadding(alg);
     const oaepHash = resolveOaepHash(alg);
     const keyObject = ensureKeyObject(key, alg, 'unwrapKey', 'decrypt');

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

@@ -8,18 +8,13 @@ import validateCrit from '../../lib/validate_crit.js';
 const recipientRef = new WeakMap();
 class IndividualRecipient {
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = recipientRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _unprotectedHeader(value) {
-        recipientRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return recipientRef.get(this).unprotectedHeader;
-    }
 }
 export class GeneralEncrypt {
     constructor(plaintext) {

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

@@ -3,31 +3,21 @@ import { JWSInvalid } from '../../util/errors.js';
 const signatureRef = new WeakMap();
 class IndividualSignature {
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        ref.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _protectedHeader(value) {
-        signatureRef.get(this).protectedHeader = value;
-    }
-    get _protectedHeader() {
-        return signatureRef.get(this).protectedHeader;
-    }
-    set _unprotectedHeader(value) {
-        signatureRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return signatureRef.get(this).unprotectedHeader;
-    }
 }
 export class GeneralSign {
     constructor(payload) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "4.2.0",
+  "version": "4.2.1",
   "description": "'JSON Web Almost Everything' - JWA, JWS, JWE, JWT, JWK, JWKS with no dependencies using runtime's native crypto",
   "keywords": [
     "browser",