jose 3.17.0 → 3.20.1

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

@@ -1,30 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const invalid_key_input_js_1 = require("../runtime/invalid_key_input.js");
-const checkKeyType = (alg, key, usage) => {
-    if (!(key instanceof Uint8Array) && !(key === null || key === void 0 ? void 0 : key.type)) {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+const is_key_like_js_1 = require("../runtime/is_key_like.js");
+const symmetricTypeCheck = (key) => {
+    if (key instanceof Uint8Array)
+        return;
+    if (!(0, is_key_like_js_1.default)(key)) {
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
     }
-    if (alg.startsWith('HS') ||
-        alg === 'dir' ||
-        alg.startsWith('PBES2') ||
-        alg.match(/^A\d{3}(?:GCM)?KW$/)) {
-        if (key instanceof Uint8Array || key.type === 'secret') {
-            return;
-        }
-        throw new TypeError('CryptoKey or KeyObject instances for symmetric algorithms must be of type "secret"');
+    if (key.type !== 'secret') {
+        throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for symmetric algorithms must be of type "secret"`);
     }
-    if (key instanceof Uint8Array) {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+};
+const asymmetricTypeCheck = (key, usage) => {
+    if (!(0, is_key_like_js_1.default)(key)) {
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
     }
     if (key.type === 'secret') {
-        throw new TypeError('CryptoKey or KeyObject instances for asymmetric algorithms must not be of type "secret"');
+        throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for asymmetric algorithms must not be of type "secret"`);
     }
     if (usage === 'sign' && key.type === 'public') {
-        throw new TypeError('CryptoKey or KeyObject instances for asymmetric algorithm signing must be of type "private"');
+        throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for asymmetric algorithm signing must be of type "private"`);
     }
     if (usage === 'decrypt' && key.type === 'public') {
-        throw new TypeError('CryptoKey or KeyObject instances for asymmetric algorithm decryption must be of type "private"');
+        throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for asymmetric algorithm decryption must be of type "private"`);
+    }
+    if (key.algorithm && usage === 'verify' && key.type === 'private') {
+        throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for asymmetric algorithm verifying must be of type "public"`);
+    }
+    if (key.algorithm && usage === 'encrypt' && key.type === 'private') {
+        throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for asymmetric algorithm encryption must be of type "public"`);
+    }
+};
+const checkKeyType = (alg, key, usage) => {
+    const symmetric = alg.startsWith('HS') ||
+        alg === 'dir' ||
+        alg.startsWith('PBES2') ||
+        /^A\d{3}(?:GCM)?KW$/.test(alg);
+    if (symmetric) {
+        symmetricTypeCheck(key);
+    }
+    else {
+        asymmetricTypeCheck(key, usage);
     }
 };
 exports.default = checkKeyType;

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

@@ -8,83 +8,83 @@ const aesgcmkw_js_1 = require("../runtime/aesgcmkw.js");
 const base64url_js_1 = require("../runtime/base64url.js");
 const errors_js_1 = require("../util/errors.js");
 const cek_js_1 = require("../lib/cek.js");
-const parse_js_1 = require("../jwk/parse.js");
+const import_js_1 = require("../key/import.js");
 const check_key_type_js_1 = require("./check_key_type.js");
-function assertEnryptedKey(encryptedKey) {
-    if (!encryptedKey) {
-        throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
-    }
-}
-function assertHeaderParameter(joseHeader, parameter, name) {
-    if (joseHeader[parameter] === undefined) {
-        throw new errors_js_1.JWEInvalid(`JOSE Header ${name} (${parameter}) missing`);
-    }
-}
+const is_object_js_1 = require("./is_object.js");
 async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
     (0, check_key_type_js_1.default)(alg, key, 'decrypt');
     switch (alg) {
         case 'dir': {
-            if (encryptedKey !== undefined) {
+            if (encryptedKey !== undefined)
                 throw new errors_js_1.JWEInvalid('Encountered unexpected JWE Encrypted Key');
-            }
             return key;
         }
         case 'ECDH-ES':
-            if (encryptedKey !== undefined) {
+            if (encryptedKey !== undefined)
                 throw new errors_js_1.JWEInvalid('Encountered unexpected JWE Encrypted Key');
-            }
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            assertHeaderParameter(joseHeader, 'epk', 'Ephemeral Public Key');
-            if (!ECDH.ecdhAllowed(key)) {
+            if (!(0, is_object_js_1.default)(joseHeader.epk))
+                throw new errors_js_1.JWEInvalid(`JOSE Header "epk" (Ephemeral Public Key) missing or invalid`);
+            if (!ECDH.ecdhAllowed(key))
                 throw new errors_js_1.JOSENotSupported('ECDH-ES with the provided key is not allowed or not supported by your javascript runtime');
-            }
-            const epk = await (0, parse_js_1.parseJwk)(joseHeader.epk, alg);
+            const epk = await (0, import_js_1.importJWK)(joseHeader.epk, alg);
             let partyUInfo;
             let partyVInfo;
-            if (joseHeader.apu !== undefined)
+            if (joseHeader.apu !== undefined) {
+                if (typeof joseHeader.apu !== 'string')
+                    throw new errors_js_1.JWEInvalid(`JOSE Header "apu" (Agreement PartyUInfo) invalid`);
                 partyUInfo = (0, base64url_js_1.decode)(joseHeader.apu);
-            if (joseHeader.apv !== undefined)
+            }
+            if (joseHeader.apv !== undefined) {
+                if (typeof joseHeader.apv !== 'string')
+                    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) || cek_js_1.bitLengths.get(joseHeader.enc), partyUInfo, partyVInfo);
-            if (alg === 'ECDH-ES') {
+            if (alg === 'ECDH-ES')
                 return sharedSecret;
-            }
-            assertEnryptedKey(encryptedKey);
-            const kwAlg = alg.substr(-6);
-            return (0, aeskw_js_1.unwrap)(kwAlg, sharedSecret, encryptedKey);
+            if (encryptedKey === undefined)
+                throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
+            return (0, aeskw_js_1.unwrap)(alg.substr(-6), sharedSecret, encryptedKey);
         }
         case 'RSA1_5':
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
-            assertEnryptedKey(encryptedKey);
+            if (encryptedKey === undefined)
+                throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
             return (0, rsaes_js_1.decrypt)(alg, key, encryptedKey);
         }
         case 'PBES2-HS256+A128KW':
         case 'PBES2-HS384+A192KW':
         case 'PBES2-HS512+A256KW': {
-            assertEnryptedKey(encryptedKey);
-            assertHeaderParameter(joseHeader, 'p2c', 'PBES2 Count');
-            assertHeaderParameter(joseHeader, 'p2s', 'PBES2 Salt');
-            const { p2c } = joseHeader;
-            const p2s = (0, base64url_js_1.decode)(joseHeader.p2s);
-            return (0, pbes2kw_js_1.decrypt)(alg, key, encryptedKey, p2c, p2s);
+            if (encryptedKey === undefined)
+                throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
+            if (typeof joseHeader.p2c !== 'number')
+                throw new errors_js_1.JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
+            if (typeof joseHeader.p2s !== 'string')
+                throw new errors_js_1.JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
+            return (0, pbes2kw_js_1.decrypt)(alg, key, encryptedKey, joseHeader.p2c, (0, base64url_js_1.decode)(joseHeader.p2s));
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
-            assertEnryptedKey(encryptedKey);
+            if (encryptedKey === undefined)
+                throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
             return (0, aeskw_js_1.unwrap)(alg, key, encryptedKey);
         }
         case 'A128GCMKW':
         case 'A192GCMKW':
         case 'A256GCMKW': {
-            assertEnryptedKey(encryptedKey);
-            assertHeaderParameter(joseHeader, 'iv', 'Initialization Vector');
-            assertHeaderParameter(joseHeader, 'tag', 'Authentication Tag');
+            if (encryptedKey === undefined)
+                throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
+            if (typeof joseHeader.iv !== 'string')
+                throw new errors_js_1.JWEInvalid(`JOSE Header "iv" (Initialization Vector) missing or invalid`);
+            if (typeof joseHeader.tag !== 'string')
+                throw new errors_js_1.JWEInvalid(`JOSE Header "tag" (Authentication Tag) missing or invalid`);
             const iv = (0, base64url_js_1.decode)(joseHeader.iv);
             const tag = (0, base64url_js_1.decode)(joseHeader.tag);
             return (0, aesgcmkw_js_1.unwrap)(alg, key, encryptedKey, iv, tag);

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

@@ -9,7 +9,7 @@ const aesgcmkw_js_1 = require("../runtime/aesgcmkw.js");
 const base64url_js_1 = require("../runtime/base64url.js");
 const cek_js_1 = require("../lib/cek.js");
 const errors_js_1 = require("../util/errors.js");
-const from_key_like_js_1 = require("../jwk/from_key_like.js");
+const export_js_1 = require("../key/export.js");
 const check_key_type_js_1 = require("./check_key_type.js");
 const generateCek = (0, cek_js_1.default)(random_js_1.default);
 async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
@@ -32,7 +32,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             const { apu, apv } = providedParameters;
             let { epk: ephemeralKey } = providedParameters;
             ephemeralKey || (ephemeralKey = await ECDH.generateEpk(key));
-            const { x, y, crv, kty } = await (0, from_key_like_js_1.fromKeyLike)(ephemeralKey);
+            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) || cek_js_1.bitLengths.get(enc), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (b64, descriptor) => {
+    const newlined = (b64.match(/.{1,64}/g) || []).join('\n');
+    return `-----BEGIN ${descriptor}-----\n${newlined}\n-----END ${descriptor}-----`;
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromSPKI = exports.fromPKCS8 = exports.toPKCS8 = exports.toSPKI = void 0;
+const crypto_1 = require("crypto");
+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("./invalid_key_input.js");
+const genericExport = (keyType, keyFormat, key) => {
+    let keyObject;
+    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
+        if (!key.extractable) {
+            throw new TypeError('CryptoKey is not extractable');
+        }
+        keyObject = (0, webcrypto_js_1.getKeyObject)(key);
+    }
+    else if ((0, is_key_object_js_1.default)(key)) {
+        keyObject = key;
+    }
+    else {
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+    }
+    if (keyObject.type !== keyType) {
+        throw new TypeError(`key is not a ${keyType} key`);
+    }
+    return keyObject.export({ format: 'pem', type: keyFormat });
+};
+const toSPKI = (key) => {
+    return genericExport('public', 'spki', key);
+};
+exports.toSPKI = toSPKI;
+const toPKCS8 = (key) => {
+    return genericExport('private', 'pkcs8', key);
+};
+exports.toPKCS8 = toPKCS8;
+const fromPKCS8 = (pem) => (0, crypto_1.createPrivateKey)({
+    key: Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, ''), 'base64'),
+    type: 'pkcs8',
+    format: 'der',
+});
+exports.fromPKCS8 = fromPKCS8;
+const fromSPKI = (pem) => (0, crypto_1.createPublicKey)({
+    key: Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, ''), 'base64'),
+    type: 'spki',
+    format: 'der',
+});
+exports.fromSPKI = fromSPKI;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.encode = void 0;
+exports.decode = exports.encode = exports.encodeBase64 = exports.decodeBase64 = void 0;
 const buffer_utils_js_1 = require("../lib/buffer_utils.js");
 let encodeImpl;
 function normalize(input) {
@@ -16,6 +16,10 @@ if (Buffer.isEncoding('base64url')) {
 else {
     encodeImpl = (input) => Buffer.from(input).toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
 }
+const decodeBase64 = (input) => Buffer.from(input, 'base64');
+exports.decodeBase64 = decodeBase64;
+const encodeBase64 = (input) => Buffer.from(input).toString('base64');
+exports.encodeBase64 = encodeBase64;
 exports.encode = encodeImpl;
 const decode = (input) => Buffer.from(normalize(input), 'base64');
 exports.decode = decode;

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

@@ -18,7 +18,11 @@ const fetchJwks = async (url, timeout, options) => {
         agent,
         timeout,
     });
-    const [response] = await (0, events_1.once)(req, 'response');
+    const [response] = (await Promise.race([(0, events_1.once)(req, 'response'), (0, events_1.once)(req, 'timeout')]));
+    if (!response) {
+        req.destroy();
+        throw new errors_js_1.JWKSTimeout();
+    }
     if (response.statusCode !== 200) {
         throw new errors_js_1.JOSEError('Expected 200 OK from the JSON Web Key Set HTTP response');
     }

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.types = void 0;
+const webcrypto_js_1 = require("./webcrypto.js");
+const is_key_object_js_1 = require("./is_key_object.js");
+exports.default = (key) => (0, is_key_object_js_1.default)(key) || (0, webcrypto_js_1.isCryptoKey)(key);
+const types = ['KeyObject'];
+exports.types = types;
+if (parseInt(process.versions.node) >= 16) {
+    types.push('CryptoKey');
+}

package/dist/node/cjs/util/errors.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JWTExpired = exports.JWSSignatureVerificationFailed = exports.JWKSMultipleMatchingKeys = exports.JWKSNoMatchingKey = exports.JWKSInvalid = exports.JWKInvalid = exports.JWTInvalid = exports.JWSInvalid = exports.JWEInvalid = exports.JWEDecryptionFailed = exports.JOSENotSupported = exports.JOSEAlgNotAllowed = exports.JWTClaimValidationFailed = exports.JOSEError = void 0;
+exports.JWTExpired = exports.JWSSignatureVerificationFailed = exports.JWKSTimeout = exports.JWKSMultipleMatchingKeys = exports.JWKSNoMatchingKey = exports.JWKSInvalid = exports.JWKInvalid = exports.JWTInvalid = exports.JWSInvalid = exports.JWEInvalid = exports.JWEDecryptionFailed = exports.JOSENotSupported = exports.JOSEAlgNotAllowed = exports.JWTClaimValidationFailed = exports.JOSEError = void 0;
 class JOSEError extends Error {
     constructor(message) {
+        var _a;
         super(message);
         this.code = JOSEError.code;
         this.name = this.constructor.name;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
+        (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
     }
 }
 exports.JOSEError = JOSEError;
@@ -106,6 +105,15 @@ class JWKSMultipleMatchingKeys extends JOSEError {
 }
 exports.JWKSMultipleMatchingKeys = JWKSMultipleMatchingKeys;
 JWKSMultipleMatchingKeys.code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
+class JWKSTimeout extends JOSEError {
+    constructor() {
+        super(...arguments);
+        this.code = JWKSTimeout.code;
+        this.message = 'request timed out';
+    }
+}
+exports.JWKSTimeout = JWKSTimeout;
+JWKSTimeout.code = 'ERR_JWKS_TIMEOUT';
 class JWSSignatureVerificationFailed extends JOSEError {
     constructor() {
         super(...arguments);

package/dist/node/esm/jwe/compact/decrypt.js

@@ -19,7 +19,11 @@ async function compactDecrypt(jwe, key, options) {
         tag: (tag || undefined),
         encrypted_key: encryptedKey || undefined,
     }, key, options);
-    return { plaintext: decrypted.plaintext, protectedHeader: decrypted.protectedHeader };
+    const result = { plaintext: decrypted.plaintext, protectedHeader: decrypted.protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: decrypted.key };
+    }
+    return result;
 }
 export { compactDecrypt };
 export default compactDecrypt;

package/dist/node/esm/jwe/flattened/decrypt.js

@@ -92,8 +92,10 @@ async function flattenedDecrypt(jwe, key, options) {
     if (jwe.encrypted_key !== undefined) {
         encryptedKey = base64url(jwe.encrypted_key);
     }
+    let resolvedKey = false;
     if (typeof key === 'function') {
         key = await key(parsedProt, jwe);
+        resolvedKey = true;
     }
     let cek;
     try {
@@ -132,6 +134,9 @@ async function flattenedDecrypt(jwe, key, options) {
     if (jwe.header !== undefined) {
         result.unprotectedHeader = jwe.header;
     }
+    if (resolvedKey) {
+        return { ...result, key };
+    }
     return result;
 }
 export { flattenedDecrypt };

package/dist/node/esm/jwk/embedded.js

@@ -1,4 +1,4 @@
-import parseJwk from './parse.js';
+import { importJWK } from '../key/import.js';
 import isObject from '../lib/is_object.js';
 import { JWSInvalid } from '../util/errors.js';
 async function EmbeddedJWK(protectedHeader, token) {
@@ -9,8 +9,8 @@ async function EmbeddedJWK(protectedHeader, token) {
     if (!isObject(joseHeader.jwk)) {
         throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a JSON object');
     }
-    const key = await parseJwk(joseHeader.jwk, joseHeader.alg, true);
-    if (key.type !== 'public') {
+    const key = await importJWK({ ...joseHeader.jwk, ext: true }, joseHeader.alg, true);
+    if (key instanceof Uint8Array || key.type !== 'public') {
         throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a public key');
     }
     return key;

package/dist/node/esm/jwk/from_key_like.js

@@ -1,6 +1,6 @@
-import asJWK from '../runtime/key_to_jwk.js';
+import { exportJWK } from '../key/export.js';
 async function fromKeyLike(key) {
-    return asJWK(key);
+    return exportJWK(key);
 }
 export { fromKeyLike };
 export default fromKeyLike;

package/dist/node/esm/jwk/parse.js

@@ -1,35 +1,6 @@
-import { decode as base64url } from '../runtime/base64url.js';
-import asKeyObject from '../runtime/jwk_to_key.js';
-import { JOSENotSupported } from '../util/errors.js';
-import isObject from '../lib/is_object.js';
+import { importJWK } from '../key/import.js';
 async function parseJwk(jwk, alg, octAsKeyObject) {
-    if (!isObject(jwk)) {
-        throw new TypeError('JWK must be an object');
-    }
-    alg || (alg = jwk.alg);
-    if (typeof alg !== 'string' || !alg) {
-        throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-    }
-    switch (jwk.kty) {
-        case 'oct':
-            if (typeof jwk.k !== 'string' || !jwk.k) {
-                throw new TypeError('missing "k" (Key Value) Parameter value');
-            }
-            octAsKeyObject !== null && octAsKeyObject !== void 0 ? octAsKeyObject : (octAsKeyObject = jwk.ext !== true);
-            if (octAsKeyObject) {
-                return asKeyObject({ ...jwk, alg, ext: false });
-            }
-            return base64url(jwk.k);
-        case 'RSA':
-            if (jwk.oth !== undefined) {
-                throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
-            }
-        case 'EC':
-        case 'OKP':
-            return asKeyObject({ ...jwk, alg });
-        default:
-            throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
-    }
+    return importJWK(jwk, alg, octAsKeyObject);
 }
 export { parseJwk };
 export default parseJwk;

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

@@ -1,9 +1,9 @@
 import fetchJwks from '../runtime/fetch_jwks.js';
-import parseJWK from '../jwk/parse.js';
+import { importJWK } from '../key/import.js';
 import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
 import isObject from '../lib/is_object.js';
 function getKtyFromAlg(alg) {
-    switch (alg.substr(0, 2)) {
+    switch (typeof alg === 'string' && alg.substr(0, 2)) {
         case 'RS':
         case 'PS':
             return 'RSA';
@@ -32,7 +32,7 @@ class RemoteJWKSet {
             typeof (options === null || options === void 0 ? void 0 : options.cooldownDuration) === 'number' ? options === null || options === void 0 ? void 0 : options.cooldownDuration : 30000;
     }
     coolingDown() {
-        if (typeof this._cooldownStarted === 'undefined') {
+        if (!this._cooldownStarted) {
             return false;
         }
         return Date.now() < this._cooldownStarted + this._cooldownDuration;
@@ -56,7 +56,7 @@ class RemoteJWKSet {
                 candidate = jwk.key_ops.includes('verify');
             }
             if (candidate && protectedHeader.alg === 'EdDSA') {
-                candidate = ['Ed25519', 'Ed448'].includes(jwk.crv);
+                candidate = jwk.crv === 'Ed25519' || jwk.crv === 'Ed448';
             }
             if (candidate) {
                 switch (protectedHeader.alg) {
@@ -88,13 +88,10 @@ class RemoteJWKSet {
         else if (length !== 1) {
             throw new JWKSMultipleMatchingKeys();
         }
-        if (!this._cached.has(jwk)) {
-            this._cached.set(jwk, {});
-        }
-        const cached = this._cached.get(jwk);
+        const cached = this._cached.get(jwk) || this._cached.set(jwk, {}).get(jwk);
         if (cached[protectedHeader.alg] === undefined) {
-            const keyObject = await parseJWK({ ...jwk, alg: protectedHeader.alg });
-            if (keyObject.type !== 'public') {
+            const keyObject = await importJWK({ ...jwk, ext: true }, protectedHeader.alg);
+            if (keyObject instanceof Uint8Array || keyObject.type !== 'public') {
                 throw new JWKSInvalid('JSON Web Key Set members must be public keys');
             }
             cached[protectedHeader.alg] = keyObject;

package/dist/node/esm/jws/compact/verify.js

@@ -17,7 +17,11 @@ async function compactVerify(jws, key, options) {
         protected: protectedHeader || undefined,
         signature: (signature || undefined),
     }, key, options);
-    return { payload: verified.payload, protectedHeader: verified.protectedHeader };
+    const result = { payload: verified.payload, protectedHeader: verified.protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: verified.key };
+    }
+    return result;
 }
 export { compactVerify };
 export default compactVerify;

package/dist/node/esm/jws/flattened/verify.js

@@ -70,8 +70,10 @@ async function flattenedVerify(jws, key, options) {
     else if (typeof jws.payload !== 'string' && !(jws.payload instanceof Uint8Array)) {
         throw new JWSInvalid('JWS Payload must be a string or an Uint8Array instance');
     }
+    let resolvedKey = false;
     if (typeof key === 'function') {
         key = await key(parsedProt, jws);
+        resolvedKey = true;
     }
     checkKeyType(alg, key, 'verify');
     const data = concat(encoder.encode((_a = jws.protected) !== null && _a !== void 0 ? _a : ''), encoder.encode('.'), typeof jws.payload === 'string' ? encoder.encode(jws.payload) : jws.payload);
@@ -97,6 +99,9 @@ async function flattenedVerify(jws, key, options) {
     if (jws.header !== undefined) {
         result.unprotectedHeader = jws.header;
     }
+    if (resolvedKey) {
+        return { ...result, key };
+    }
     return result;
 }
 export { flattenedVerify };

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

@@ -15,7 +15,11 @@ async function jwtDecrypt(jwt, key, options) {
         JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)) {
         throw new JWTClaimValidationFailed('replicated "aud" claim header parameter mismatch', 'aud', 'mismatch');
     }
-    return { payload, protectedHeader };
+    const result = { payload, protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: decrypted.key };
+    }
+    return result;
 }
 export { jwtDecrypt };
 export default jwtDecrypt;

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

@@ -1,6 +1,6 @@
 import CompactEncrypt from '../jwe/compact/encrypt.js';
 import { encoder } from '../lib/buffer_utils.js';
-import ProduceJWT from '../lib/jwt_producer.js';
+import { ProduceJWT } from './produce.js';
 class EncryptJWT extends ProduceJWT {
     setProtectedHeader(protectedHeader) {
         if (this._protectedHeader) {

package/dist/node/esm/{lib/jwt_producer.js → jwt/produce.js}

@@ -1,7 +1,7 @@
-import epoch from './epoch.js';
-import isObject from './is_object.js';
-import secs from './secs.js';
-export default class ProduceJWT {
+import epoch from '../lib/epoch.js';
+import isObject from '../lib/is_object.js';
+import secs from '../lib/secs.js';
+export class ProduceJWT {
     constructor(payload) {
         if (!isObject(payload)) {
             throw new TypeError('JWT Claims Set MUST be an object');

package/dist/node/esm/jwt/sign.js

@@ -1,7 +1,7 @@
 import CompactSign from '../jws/compact/sign.js';
 import { JWTInvalid } from '../util/errors.js';
 import { encoder } from '../lib/buffer_utils.js';
-import ProduceJWT from '../lib/jwt_producer.js';
+import { ProduceJWT } from './produce.js';
 class SignJWT extends ProduceJWT {
     setProtectedHeader(protectedHeader) {
         this._protectedHeader = protectedHeader;

package/dist/node/esm/jwt/unsecured.js

@@ -2,7 +2,7 @@ import * as base64url from '../runtime/base64url.js';
 import { decoder } from '../lib/buffer_utils.js';
 import { JWTInvalid } from '../util/errors.js';
 import jwtPayload from '../lib/jwt_claims_set.js';
-import ProduceJWT from '../lib/jwt_producer.js';
+import { ProduceJWT } from './produce.js';
 class UnsecuredJWT extends ProduceJWT {
     encode() {
         const header = base64url.encode(JSON.stringify({ alg: 'none' }));

package/dist/node/esm/jwt/verify.js

@@ -8,7 +8,11 @@ async function jwtVerify(jwt, key, options) {
         throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
     }
     const payload = jwtPayload(verified.protectedHeader, verified.payload, options);
-    return { payload, protectedHeader: verified.protectedHeader };
+    const result = { payload, protectedHeader: verified.protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: verified.key };
+    }
+    return result;
 }
 export { jwtVerify };
 export default jwtVerify;

package/dist/node/esm/key/export.js

@@ -0,0 +1,12 @@
+import { toSPKI as exportPublic } from '../runtime/asn1.js';
+import { toPKCS8 as exportPrivate } from '../runtime/asn1.js';
+import keyToJWK from '../runtime/key_to_jwk.js';
+export async function exportSPKI(key) {
+    return exportPublic(key);
+}
+export async function exportPKCS8(key) {
+    return exportPrivate(key);
+}
+export async function exportJWK(key) {
+    return keyToJWK(key);
+}