jose 3.20.1 → 3.20.4

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

@@ -4,18 +4,16 @@ exports.unwrap = exports.wrap = void 0;
 const encrypt_js_1 = require("./encrypt.js");
 const decrypt_js_1 = require("./decrypt.js");
 const iv_js_1 = require("../lib/iv.js");
-const random_js_1 = require("./random.js");
 const base64url_js_1 = require("./base64url.js");
-const generateIv = (0, iv_js_1.default)(random_js_1.default);
 const wrap = async (alg, key, cek, iv) => {
     const jweAlgorithm = alg.substr(0, 7);
-    iv || (iv = generateIv(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');

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

@@ -6,7 +6,7 @@ const util_1 = require("util");
 const random_js_1 = require("./random.js");
 const check_modulus_length_js_1 = require("./check_modulus_length.js");
 const errors_js_1 = require("../util/errors.js");
-const generate = (0, util_1.promisify)(crypto_1.generateKeyPair);
+const generate = util_1.promisify(crypto_1.generateKeyPair);
 async function generateSecret(alg, options) {
     let length;
     switch (alg) {
@@ -32,7 +32,7 @@ async function generateSecret(alg, options) {
         default:
             throw new errors_js_1.JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
     }
-    return (0, crypto_1.createSecretKey)((0, random_js_1.default)(new Uint8Array(length >> 3)));
+    return crypto_1.createSecretKey(random_js_1.default(new Uint8Array(length >> 3)));
 }
 exports.generateSecret = generateSecret;
 async function generateKeyPair(alg, options) {
@@ -57,8 +57,8 @@ async function generateKeyPair(alg, options) {
                 modulusLength,
                 publicExponent: 0x10001,
             });
-            (0, check_modulus_length_js_1.setModulusLength)(keypair.privateKey, modulusLength);
-            (0, check_modulus_length_js_1.setModulusLength)(keypair.publicKey, modulusLength);
+            check_modulus_length_js_1.setModulusLength(keypair.privateKey, modulusLength);
+            check_modulus_length_js_1.setModulusLength(keypair.publicKey, modulusLength);
             return keypair;
         }
         case 'ES256':

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

@@ -28,14 +28,14 @@ const namedCurveToJOSE = (namedCurve) => {
 const getNamedCurve = (kee, raw) => {
     var _a;
     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'));
     }
     if (key.type === 'secret') {
         throw new TypeError('only "private" or "public" type keys can be used for this operation');
@@ -53,7 +53,7 @@ const getNamedCurve = (kee, raw) => {
             }
             let namedCurve = (_a = key.asymmetricKeyDetails) === null || _a === void 0 ? void 0 : _a.namedCurve;
             if (!namedCurve && key.type === 'private') {
-                namedCurve = getNamedCurve((0, crypto_1.createPublicKey)(key), true);
+                namedCurve = getNamedCurve(crypto_1.createPublicKey(key), true);
             }
             else if (!namedCurve) {
                 const buf = key.export({ format: 'der', type: 'spki' });

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

@@ -7,16 +7,16 @@ const invalid_key_input_js_1 = require("./invalid_key_input.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(invalid_key_input_js_1.default(key, 'KeyObject', 'CryptoKey'));
         }
-        return (0, secret_key_js_1.default)(key);
+        return secret_key_js_1.default(key);
     }
     if (key instanceof crypto.KeyObject) {
         return 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'));
 }
 exports.default = getSignVerifyKey;

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

@@ -24,12 +24,12 @@ exports.default = (actual, ...types) => {
             msg += ` Received an instance of ${actual.constructor.name}`;
         }
         else {
-            const inspected = (0, util_1.inspect)(actual, { depth: -1 });
+            const inspected = util_1.inspect(actual, { depth: -1 });
             msg += ` Received ${inspected}`;
         }
     }
     else {
-        let inspected = (0, util_1.inspect)(actual, { colors: false });
+        let inspected = util_1.inspect(actual, { colors: false });
         if (inspected.length > 25)
             inspected = `${inspected.slice(0, 25)}...`;
         msg += ` Received type ${typeof actual} (${inspected})`;

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

@@ -3,7 +3,7 @@ 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);
+exports.default = (key) => is_key_object_js_1.default(key) || webcrypto_js_1.isCryptoKey(key);
 const types = ['KeyObject'];
 exports.types = types;
 if (parseInt(process.versions.node) >= 16) {

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

@@ -14,12 +14,12 @@ const jwkImportSupported = major >= 16 || (major === 15 && minor >= 12);
 const parse = (jwk) => {
     if (jwkImportSupported && jwk.kty !== 'oct') {
         return jwk.d
-            ? (0, crypto_1.createPrivateKey)({ format: 'jwk', key: jwk })
-            : (0, crypto_1.createPublicKey)({ format: 'jwk', key: jwk });
+            ? crypto_1.createPrivateKey({ format: 'jwk', key: jwk })
+            : crypto_1.createPublicKey({ format: 'jwk', key: jwk });
     }
     switch (jwk.kty) {
         case 'oct': {
-            return (0, crypto_1.createSecretKey)((0, base64url_js_1.decode)(jwk.k));
+            return crypto_1.createSecretKey(base64url_js_1.decode(jwk.k));
         }
         case 'RSA': {
             const enc = new asn1_sequence_encoder_js_1.default();
@@ -47,8 +47,8 @@ const parse = (jwk) => {
                 format: 'der',
                 type: 'pkcs1',
             };
-            const keyObject = isPrivate ? (0, crypto_1.createPrivateKey)(createInput) : (0, crypto_1.createPublicKey)(createInput);
-            (0, check_modulus_length_js_1.setModulusLength)(keyObject, modulus.length << 3);
+            const keyObject = isPrivate ? crypto_1.createPrivateKey(createInput) : crypto_1.createPublicKey(createInput);
+            check_modulus_length_js_1.setModulusLength(keyObject, modulus.length << 3);
             return keyObject;
         }
         case 'EC': {
@@ -78,8 +78,8 @@ const parse = (jwk) => {
                 const f3 = enc$4.end(Buffer.from([0x04]));
                 enc.add(f3);
                 const der = enc.end();
-                const keyObject = (0, crypto_1.createPrivateKey)({ key: der, format: 'der', type: 'pkcs8' });
-                (0, get_named_curve_js_1.setCurve)(keyObject, jwk.crv);
+                const keyObject = crypto_1.createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
+                get_named_curve_js_1.setCurve(keyObject, jwk.crv);
                 return keyObject;
             }
             const enc$1 = new asn1_sequence_encoder_js_1.default();
@@ -88,8 +88,8 @@ const parse = (jwk) => {
             enc.add(enc$1.end());
             enc.bitStr(pub);
             const der = enc.end();
-            const keyObject = (0, crypto_1.createPublicKey)({ key: der, format: 'der', type: 'spki' });
-            (0, get_named_curve_js_1.setCurve)(keyObject, jwk.crv);
+            const keyObject = crypto_1.createPublicKey({ key: der, format: 'der', type: 'spki' });
+            get_named_curve_js_1.setCurve(keyObject, jwk.crv);
             return keyObject;
         }
         case 'OKP': {
@@ -105,14 +105,14 @@ const parse = (jwk) => {
                 const f = enc$2.end(Buffer.from([0x04]));
                 enc.add(f);
                 const der = enc.end();
-                return (0, crypto_1.createPrivateKey)({ key: der, format: 'der', type: 'pkcs8' });
+                return crypto_1.createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
             }
             const enc$1 = new asn1_sequence_encoder_js_1.default();
             enc$1.oidFor(jwk.crv);
             enc.add(enc$1.end());
             enc.bitStr(Buffer.from(jwk.x, 'base64'));
             const der = enc.end();
-            return (0, crypto_1.createPublicKey)({ key: der, format: 'der', type: 'spki' });
+            return crypto_1.createPublicKey({ key: der, format: 'der', type: 'spki' });
         }
         default:
             throw new errors_js_1.JOSENotSupported('Invalid or unsupported JWK "kty" (Key Type) Parameter value');