jose 3.20.3 → 3.20.4

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

@@ -5,16 +5,16 @@ 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 (!is_key_like_js_1.default(key)) {
+        throw new TypeError(invalid_key_input_js_1.default(key, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     if (key.type !== 'secret') {
         throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for symmetric algorithms must be of type "secret"`);
     }
 };
 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 (!is_key_like_js_1.default(key)) {
+        throw new TypeError(invalid_key_input_js_1.default(key, ...is_key_like_js_1.types));
     }
     if (key.type === 'secret') {
         throw new TypeError(`${is_key_like_js_1.types.join(' or ')} instances for asymmetric algorithms must not be of type "secret"`);

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

@@ -11,8 +11,8 @@ const cek_js_1 = require("../lib/cek.js");
 const import_js_1 = require("../key/import.js");
 const check_key_type_js_1 = require("./check_key_type.js");
 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');
+async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options) {
+    check_key_type_js_1.default(alg, key, 'decrypt');
     switch (alg) {
         case 'dir': {
             if (encryptedKey !== undefined)
@@ -25,29 +25,29 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            if (!(0, is_object_js_1.default)(joseHeader.epk))
+            if (!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, import_js_1.importJWK)(joseHeader.epk, alg);
+            const epk = await import_js_1.importJWK(joseHeader.epk, alg);
             let partyUInfo;
             let partyVInfo;
             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);
+                partyUInfo = base64url_js_1.decode(joseHeader.apu);
             }
             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);
+                partyVInfo = 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')
                 return sharedSecret;
             if (encryptedKey === undefined)
                 throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
-            return (0, aeskw_js_1.unwrap)(alg.substr(-6), sharedSecret, encryptedKey);
+            return aeskw_js_1.unwrap(alg.substr(-6), sharedSecret, encryptedKey);
         }
         case 'RSA1_5':
         case 'RSA-OAEP':
@@ -56,7 +56,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
         case 'RSA-OAEP-512': {
             if (encryptedKey === undefined)
                 throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
-            return (0, rsaes_js_1.decrypt)(alg, key, encryptedKey);
+            return rsaes_js_1.decrypt(alg, key, encryptedKey);
         }
         case 'PBES2-HS256+A128KW':
         case 'PBES2-HS384+A192KW':
@@ -65,16 +65,19 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
                 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`);
+            const p2cLimit = (options === null || options === void 0 ? void 0 : options.maxPBES2Count) || 10000;
+            if (joseHeader.p2c > p2cLimit)
+                throw new errors_js_1.JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
             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));
+            return pbes2kw_js_1.decrypt(alg, key, encryptedKey, joseHeader.p2c, base64url_js_1.decode(joseHeader.p2s));
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
             if (encryptedKey === undefined)
                 throw new errors_js_1.JWEInvalid('JWE Encrypted Key missing');
-            return (0, aeskw_js_1.unwrap)(alg, key, encryptedKey);
+            return aeskw_js_1.unwrap(alg, key, encryptedKey);
         }
         case 'A128GCMKW':
         case 'A192GCMKW':
@@ -85,9 +88,9 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
                 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);
+            const iv = base64url_js_1.decode(joseHeader.iv);
+            const tag = base64url_js_1.decode(joseHeader.tag);
+            return aesgcmkw_js_1.unwrap(alg, key, encryptedKey, iv, tag);
         }
         default: {
             throw new errors_js_1.JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value');

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

@@ -14,7 +14,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
     let encryptedKey;
     let parameters;
     let cek;
-    (0, check_key_type_js_1.default)(alg, key, 'encrypt');
+    check_key_type_js_1.default(alg, key, 'encrypt');
     switch (alg) {
         case 'dir': {
             cek = key;
@@ -30,20 +30,20 @@ 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, export_js_1.exportJWK)(ephemeralKey);
+            const { x, y, crv, kty } = await 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)
-                parameters.apu = (0, base64url_js_1.encode)(apu);
+                parameters.apu = base64url_js_1.encode(apu);
             if (apv)
-                parameters.apv = (0, base64url_js_1.encode)(apv);
+                parameters.apv = base64url_js_1.encode(apv);
             if (alg === 'ECDH-ES') {
                 cek = sharedSecret;
                 break;
             }
-            cek = providedCek || (0, cek_js_1.default)(enc);
+            cek = providedCek || cek_js_1.default(enc);
             const kwAlg = alg.substr(-6);
-            encryptedKey = await (0, aeskw_js_1.wrap)(kwAlg, sharedSecret, cek);
+            encryptedKey = await aeskw_js_1.wrap(kwAlg, sharedSecret, cek);
             break;
         }
         case 'RSA1_5':
@@ -51,31 +51,31 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
-            cek = providedCek || (0, cek_js_1.default)(enc);
-            encryptedKey = await (0, rsaes_js_1.encrypt)(alg, key, cek);
+            cek = providedCek || cek_js_1.default(enc);
+            encryptedKey = await rsaes_js_1.encrypt(alg, key, cek);
             break;
         }
         case 'PBES2-HS256+A128KW':
         case 'PBES2-HS384+A192KW':
         case 'PBES2-HS512+A256KW': {
-            cek = providedCek || (0, cek_js_1.default)(enc);
+            cek = providedCek || cek_js_1.default(enc);
             const { p2c, p2s } = providedParameters;
-            ({ encryptedKey, ...parameters } = await (0, pbes2kw_js_1.encrypt)(alg, key, cek, p2c, p2s));
+            ({ encryptedKey, ...parameters } = await pbes2kw_js_1.encrypt(alg, key, cek, p2c, p2s));
             break;
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
-            cek = providedCek || (0, cek_js_1.default)(enc);
-            encryptedKey = await (0, aeskw_js_1.wrap)(alg, key, cek);
+            cek = providedCek || cek_js_1.default(enc);
+            encryptedKey = await aeskw_js_1.wrap(alg, key, cek);
             break;
         }
         case 'A128GCMKW':
         case 'A192GCMKW':
         case 'A256GCMKW': {
-            cek = providedCek || (0, cek_js_1.default)(enc);
+            cek = providedCek || cek_js_1.default(enc);
             const { iv } = providedParameters;
-            ({ encryptedKey, ...parameters } = await (0, aesgcmkw_js_1.wrap)(alg, key, cek, iv));
+            ({ encryptedKey, ...parameters } = await aesgcmkw_js_1.wrap(alg, key, cek, iv));
             break;
         }
         default: {

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

@@ -20,6 +20,6 @@ const generateIv = (alg) => {
     if (!bitLength) {
         throw new errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
-    return (0, random_js_1.default)(new Uint8Array(bitLength >> 3));
+    return random_js_1.default(new Uint8Array(bitLength >> 3));
 };
 exports.default = generateIv;

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

@@ -28,7 +28,7 @@ exports.default = (protectedHeader, encodedPayload, options = {}) => {
     }
     catch {
     }
-    if (!(0, is_object_js_1.default)(payload)) {
+    if (!is_object_js_1.default(payload)) {
         throw new errors_js_1.JWTInvalid('JWT Claims Set must be a top-level JSON object');
     }
     const { issuer } = options;
@@ -47,7 +47,7 @@ exports.default = (protectedHeader, encodedPayload, options = {}) => {
     let tolerance;
     switch (typeof options.clockTolerance) {
         case 'string':
-            tolerance = (0, secs_js_1.default)(options.clockTolerance);
+            tolerance = secs_js_1.default(options.clockTolerance);
             break;
         case 'number':
             tolerance = options.clockTolerance;
@@ -59,7 +59,7 @@ exports.default = (protectedHeader, encodedPayload, options = {}) => {
             throw new TypeError('Invalid clockTolerance option type');
     }
     const { currentDate } = options;
-    const now = (0, epoch_js_1.default)(currentDate || new Date());
+    const now = epoch_js_1.default(currentDate || new Date());
     if (payload.iat !== undefined || options.maxTokenAge) {
         if (typeof payload.iat !== 'number') {
             throw new errors_js_1.JWTClaimValidationFailed('"iat" claim must be a number', 'iat', 'invalid');
@@ -86,7 +86,7 @@ exports.default = (protectedHeader, encodedPayload, options = {}) => {
     }
     if (options.maxTokenAge) {
         const age = now - payload.iat;
-        const max = typeof options.maxTokenAge === 'number' ? options.maxTokenAge : (0, secs_js_1.default)(options.maxTokenAge);
+        const max = typeof options.maxTokenAge === 'number' ? options.maxTokenAge : secs_js_1.default(options.maxTokenAge);
         if (age - tolerance > max) {
             throw new errors_js_1.JWTExpired('"iat" claim timestamp check failed (too far in the past)', 'iat', 'check_failed');
         }

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

@@ -7,13 +7,13 @@ const iv_js_1 = require("../lib/iv.js");
 const base64url_js_1 = require("./base64url.js");
 const wrap = async (alg, key, cek, iv) => {
     const jweAlgorithm = alg.substr(0, 7);
-    iv || (iv = (0, iv_js_1.default)(jweAlgorithm));
-    const { ciphertext: encryptedKey, tag } = await (0, encrypt_js_1.default)(jweAlgorithm, cek, key, iv, new Uint8Array(0));
-    return { encryptedKey, iv: (0, base64url_js_1.encode)(iv), tag: (0, base64url_js_1.encode)(tag) };
+    iv || (iv = iv_js_1.default(jweAlgorithm));
+    const { ciphertext: encryptedKey, tag } = await encrypt_js_1.default(jweAlgorithm, cek, key, iv, new Uint8Array(0));
+    return { encryptedKey, iv: base64url_js_1.encode(iv), tag: base64url_js_1.encode(tag) };
 };
 exports.wrap = wrap;
 const unwrap = async (alg, key, encryptedKey, iv, tag) => {
     const jweAlgorithm = alg.substr(0, 7);
-    return (0, decrypt_js_1.default)(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
+    return decrypt_js_1.default(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
 };
 exports.unwrap = unwrap;

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

@@ -15,38 +15,38 @@ function checkKeySize(key, alg) {
     }
 }
 function ensureKeyObject(key, alg, usage) {
-    if ((0, is_key_object_js_1.default)(key)) {
+    if (is_key_object_js_1.default(key)) {
         return key;
     }
     if (key instanceof Uint8Array) {
-        return (0, secret_key_js_1.default)(key);
+        return secret_key_js_1.default(key);
     }
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        return (0, webcrypto_js_1.getKeyObject)(key, alg, new Set([usage]));
+    if (webcrypto_js_1.isCryptoKey(key)) {
+        return webcrypto_js_1.getKeyObject(key, alg, new Set([usage]));
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalid_key_input_js_1.default(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
 }
 const wrap = async (alg, key, cek) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
+    if (!ciphers_js_1.default(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }
     const keyObject = ensureKeyObject(key, alg, 'wrapKey');
     checkKeySize(keyObject, alg);
-    const cipher = (0, crypto_1.createCipheriv)(algorithm, keyObject, Buffer.alloc(8, 0xa6));
-    return (0, buffer_utils_js_1.concat)(cipher.update(cek), cipher.final());
+    const cipher = crypto_1.createCipheriv(algorithm, keyObject, Buffer.alloc(8, 0xa6));
+    return buffer_utils_js_1.concat(cipher.update(cek), cipher.final());
 };
 exports.wrap = wrap;
 const unwrap = async (alg, key, encryptedKey) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
+    if (!ciphers_js_1.default(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }
     const keyObject = ensureKeyObject(key, alg, 'unwrapKey');
     checkKeySize(keyObject, alg);
-    const cipher = (0, crypto_1.createDecipheriv)(algorithm, keyObject, Buffer.alloc(8, 0xa6));
-    return (0, buffer_utils_js_1.concat)(cipher.update(encryptedKey), cipher.final());
+    const cipher = crypto_1.createDecipheriv(algorithm, keyObject, Buffer.alloc(8, 0xa6));
+    return buffer_utils_js_1.concat(cipher.update(encryptedKey), cipher.final());
 };
 exports.unwrap = unwrap;

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

@@ -7,17 +7,17 @@ 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 (webcrypto_js_1.isCryptoKey(key)) {
         if (!key.extractable) {
             throw new TypeError('CryptoKey is not extractable');
         }
-        keyObject = (0, webcrypto_js_1.getKeyObject)(key);
+        keyObject = webcrypto_js_1.getKeyObject(key);
     }
-    else if ((0, is_key_object_js_1.default)(key)) {
+    else if (is_key_object_js_1.default(key)) {
         keyObject = key;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalid_key_input_js_1.default(key, 'KeyObject', 'CryptoKey'));
     }
     if (keyObject.type !== keyType) {
         throw new TypeError(`key is not a ${keyType} key`);
@@ -32,13 +32,13 @@ const toPKCS8 = (key) => {
     return genericExport('private', 'pkcs8', key);
 };
 exports.toPKCS8 = toPKCS8;
-const fromPKCS8 = (pem) => (0, crypto_1.createPrivateKey)({
+const fromPKCS8 = (pem) => 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)({
+const fromSPKI = (pem) => crypto_1.createPublicKey({
     key: Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, ''), 'base64'),
     type: 'spki',
     format: 'der',

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

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
 const buffer_utils_js_1 = require("../lib/buffer_utils.js");
 function cbcTag(aad, iv, ciphertext, macSize, macKey, keySize) {
-    const macData = (0, buffer_utils_js_1.concat)(aad, iv, ciphertext, (0, buffer_utils_js_1.uint64be)(aad.length << 3));
-    const hmac = (0, crypto_1.createHmac)(`sha${macSize}`, macKey);
+    const macData = buffer_utils_js_1.concat(aad, iv, ciphertext, buffer_utils_js_1.uint64be(aad.length << 3));
+    const hmac = crypto_1.createHmac(`sha${macSize}`, macKey);
     hmac.update(macData);
     return hmac.digest().slice(0, keySize >> 3);
 }

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

@@ -24,7 +24,7 @@ const checkCekLength = (enc, cek) => {
         }
         return;
     }
-    if ((0, is_key_object_js_1.default)(cek) && cek.type === 'secret') {
+    if (is_key_object_js_1.default(cek) && cek.type === 'secret') {
         if (cek.symmetricKeySize << 3 !== expected) {
             throw new errors_js_1.JWEInvalid('Invalid Content Encryption Key length');
         }

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

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
 let ciphers;
 exports.default = (algorithm) => {
-    ciphers || (ciphers = new Set((0, crypto_1.getCiphers)()));
+    ciphers || (ciphers = new Set(crypto_1.getCiphers()));
     return ciphers.has(algorithm);
 };

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

@@ -13,20 +13,20 @@ const invalid_key_input_js_1 = require("./invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
 async 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)) {
+    if (is_key_object_js_1.default(cek)) {
         cek = cek.export();
     }
     const encKey = cek.subarray(keySize >> 3);
     const macKey = cek.subarray(0, keySize >> 3);
     const macSize = parseInt(enc.substr(-3), 10);
     const algorithm = `aes-${keySize}-cbc`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
+    if (!ciphers_js_1.default(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
-    const expectedTag = (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize);
+    const expectedTag = cbc_tag_js_1.default(aad, iv, ciphertext, macSize, macKey, keySize);
     let macCheckPassed;
     try {
-        macCheckPassed = (0, timing_safe_equal_js_1.default)(tag, expectedTag);
+        macCheckPassed = timing_safe_equal_js_1.default(tag, expectedTag);
     }
     catch {
     }
@@ -35,8 +35,8 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     let plaintext;
     try {
-        const cipher = (0, crypto_1.createDecipheriv)(algorithm, encKey, iv);
-        plaintext = (0, buffer_utils_js_1.concat)(cipher.update(ciphertext), cipher.final());
+        const cipher = crypto_1.createDecipheriv(algorithm, encKey, iv);
+        plaintext = buffer_utils_js_1.concat(cipher.update(ciphertext), cipher.final());
     }
     catch {
     }
@@ -48,16 +48,16 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 async 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)) {
+    if (!ciphers_js_1.default(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
     try {
-        const cipher = (0, crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
+        const cipher = crypto_1.createDecipheriv(algorithm, cek, iv, { authTagLength: 16 });
         cipher.setAuthTag(tag);
         if (aad.byteLength) {
             cipher.setAAD(aad, { plaintextLength: ciphertext.length });
         }
-        return (0, buffer_utils_js_1.concat)(cipher.update(ciphertext), cipher.final());
+        return buffer_utils_js_1.concat(cipher.update(ciphertext), cipher.final());
     }
     catch {
         throw new errors_js_1.JWEDecryptionFailed();
@@ -65,17 +65,17 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 }
 const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
     let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
-        key = (0, webcrypto_js_1.getKeyObject)(cek, enc, new Set(['decrypt']));
+    if (webcrypto_js_1.isCryptoKey(cek)) {
+        key = webcrypto_js_1.getKeyObject(cek, enc, new Set(['decrypt']));
     }
-    else if (cek instanceof Uint8Array || (0, is_key_object_js_1.default)(cek)) {
+    else if (cek instanceof Uint8Array || is_key_object_js_1.default(cek)) {
         key = cek;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalid_key_input_js_1.default(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
     }
-    (0, check_cek_length_js_1.default)(enc, key);
-    (0, check_iv_length_js_1.default)(enc, iv);
+    check_cek_length_js_1.default(enc, key);
+    check_iv_length_js_1.default(enc, iv);
     switch (enc) {
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':

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

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
-const digest = (algorithm, data) => (0, crypto_1.createHash)(algorithm).update(data).digest();
+const digest = (algorithm, data) => crypto_1.createHash(algorithm).update(data).digest();
 exports.default = digest;

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

@@ -10,43 +10,43 @@ 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("./invalid_key_input.js");
-const generateKeyPair = (0, util_1.promisify)(crypto_1.generateKeyPair);
+const generateKeyPair = util_1.promisify(crypto_1.generateKeyPair);
 const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     let publicKey;
-    if ((0, webcrypto_js_1.isCryptoKey)(publicKee)) {
-        publicKey = (0, webcrypto_js_1.getKeyObject)(publicKee, 'ECDH-ES');
+    if (webcrypto_js_1.isCryptoKey(publicKee)) {
+        publicKey = webcrypto_js_1.getKeyObject(publicKee, 'ECDH-ES');
     }
-    else if ((0, is_key_object_js_1.default)(publicKee)) {
+    else if (is_key_object_js_1.default(publicKee)) {
         publicKey = publicKee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalid_key_input_js_1.default(publicKee, 'KeyObject', 'CryptoKey'));
     }
     let privateKey;
-    if ((0, webcrypto_js_1.isCryptoKey)(privateKee)) {
-        privateKey = (0, webcrypto_js_1.getKeyObject)(privateKee, 'ECDH-ES', new Set(['deriveBits', 'deriveKey']));
+    if (webcrypto_js_1.isCryptoKey(privateKee)) {
+        privateKey = webcrypto_js_1.getKeyObject(privateKee, 'ECDH-ES', new Set(['deriveBits', 'deriveKey']));
     }
-    else if ((0, is_key_object_js_1.default)(privateKee)) {
+    else if (is_key_object_js_1.default(privateKee)) {
         privateKey = privateKee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalid_key_input_js_1.default(privateKee, 'KeyObject', 'CryptoKey'));
     }
-    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 });
-    return (0, buffer_utils_js_1.concatKdf)(digest_js_1.default, sharedSecret, keyLength, value);
+    const value = buffer_utils_js_1.concat(buffer_utils_js_1.lengthAndInput(buffer_utils_js_1.encoder.encode(algorithm)), buffer_utils_js_1.lengthAndInput(apu), buffer_utils_js_1.lengthAndInput(apv), buffer_utils_js_1.uint32be(keyLength));
+    const sharedSecret = crypto_1.diffieHellman({ privateKey, publicKey });
+    return buffer_utils_js_1.concatKdf(digest_js_1.default, sharedSecret, keyLength, value);
 };
 exports.deriveKey = deriveKey;
 const generateEpk = async (kee) => {
     let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(kee)) {
-        key = (0, webcrypto_js_1.getKeyObject)(kee);
+    if (webcrypto_js_1.isCryptoKey(kee)) {
+        key = webcrypto_js_1.getKeyObject(kee);
     }
-    else if ((0, is_key_object_js_1.default)(kee)) {
+    else if (is_key_object_js_1.default(kee)) {
         key = kee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(kee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError(invalid_key_input_js_1.default(kee, 'KeyObject', 'CryptoKey'));
     }
     switch (key.asymmetricKeyType) {
         case 'x25519':
@@ -55,7 +55,7 @@ const generateEpk = async (kee) => {
             return (await generateKeyPair('x448')).privateKey;
         }
         case 'ec': {
-            const namedCurve = (0, get_named_curve_js_1.default)(key);
+            const namedCurve = get_named_curve_js_1.default(key);
             return (await generateKeyPair('ec', { namedCurve })).privateKey;
         }
         default:
@@ -63,5 +63,5 @@ const generateEpk = async (kee) => {
     }
 };
 exports.generateEpk = generateEpk;
-const ecdhAllowed = (key) => ['P-256', 'P-384', 'P-521', 'X25519', 'X448'].includes((0, get_named_curve_js_1.default)(key));
+const ecdhAllowed = (key) => ['P-256', 'P-384', 'P-521', 'X25519', 'X448'].includes(get_named_curve_js_1.default(key));
 exports.ecdhAllowed = ecdhAllowed;

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

@@ -12,48 +12,48 @@ const errors_js_1 = require("../util/errors.js");
 const ciphers_js_1 = require("./ciphers.js");
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
-    if ((0, is_key_object_js_1.default)(cek)) {
+    if (is_key_object_js_1.default(cek)) {
         cek = cek.export();
     }
     const encKey = cek.subarray(keySize >> 3);
     const macKey = cek.subarray(0, keySize >> 3);
     const algorithm = `aes-${keySize}-cbc`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
+    if (!ciphers_js_1.default(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
-    const cipher = (0, crypto_1.createCipheriv)(algorithm, encKey, iv);
-    const ciphertext = (0, buffer_utils_js_1.concat)(cipher.update(plaintext), cipher.final());
+    const cipher = crypto_1.createCipheriv(algorithm, encKey, iv);
+    const ciphertext = buffer_utils_js_1.concat(cipher.update(plaintext), cipher.final());
     const macSize = parseInt(enc.substr(-3), 10);
-    const tag = (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize);
+    const tag = cbc_tag_js_1.default(aad, iv, ciphertext, macSize, macKey, keySize);
     return { ciphertext, tag };
 }
 async 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)) {
+    if (!ciphers_js_1.default(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
-    const cipher = (0, crypto_1.createCipheriv)(algorithm, cek, iv, { authTagLength: 16 });
+    const cipher = crypto_1.createCipheriv(algorithm, cek, iv, { authTagLength: 16 });
     if (aad.byteLength) {
         cipher.setAAD(aad, { plaintextLength: plaintext.length });
     }
-    const ciphertext = (0, buffer_utils_js_1.concat)(cipher.update(plaintext), cipher.final());
+    const ciphertext = buffer_utils_js_1.concat(cipher.update(plaintext), cipher.final());
     const tag = cipher.getAuthTag();
     return { ciphertext, tag };
 }
 const encrypt = async (enc, plaintext, cek, iv, aad) => {
     let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
-        key = (0, webcrypto_js_1.getKeyObject)(cek, enc, new Set(['encrypt']));
+    if (webcrypto_js_1.isCryptoKey(cek)) {
+        key = webcrypto_js_1.getKeyObject(cek, enc, new Set(['encrypt']));
     }
-    else if (cek instanceof Uint8Array || (0, is_key_object_js_1.default)(cek)) {
+    else if (cek instanceof Uint8Array || is_key_object_js_1.default(cek)) {
         key = cek;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalid_key_input_js_1.default(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
     }
-    (0, check_cek_length_js_1.default)(enc, key);
-    (0, check_iv_length_js_1.default)(enc, iv);
+    check_cek_length_js_1.default(enc, key);
+    check_iv_length_js_1.default(enc, iv);
     switch (enc) {
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':

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

@@ -18,7 +18,7 @@ const fetchJwks = async (url, timeout, options) => {
         agent,
         timeout,
     });
-    const [response] = (await Promise.race([(0, events_1.once)(req, 'response'), (0, events_1.once)(req, 'timeout')]));
+    const [response] = (await Promise.race([events_1.once(req, 'response'), events_1.once(req, 'timeout')]));
     if (!response) {
         req.destroy();
         throw new errors_js_1.JWKSTimeout();
@@ -31,7 +31,7 @@ const fetchJwks = async (url, timeout, options) => {
         parts.push(part);
     }
     try {
-        return JSON.parse(buffer_utils_js_1.decoder.decode((0, buffer_utils_js_1.concat)(...parts)));
+        return JSON.parse(buffer_utils_js_1.decoder.decode(buffer_utils_js_1.concat(...parts)));
     }
     catch {
         throw new errors_js_1.JOSEError('Failed to parse the JSON Web Key Set HTTP response as JSON');