jose 3.20.3 → 3.20.4

package/dist/browser/jwe/flattened/decrypt.js

@@ -95,10 +95,10 @@ async function flattenedDecrypt(jwe, key, options) {
     }
     let cek;
     try {
-        cek = await decryptKeyManagement(alg, key, encryptedKey, joseHeader);
+        cek = await decryptKeyManagement(alg, key, encryptedKey, joseHeader, options);
     }
     catch (err) {
-        if (err instanceof TypeError) {
+        if (err instanceof TypeError || err instanceof JWEInvalid || err instanceof JOSENotSupported) {
             throw err;
         }
         cek = generateCek(enc);

package/dist/browser/lib/decrypt_key_management.js

@@ -9,7 +9,7 @@ import { bitLengths as cekLengths } from '../lib/cek.js';
 import { importJWK } from '../key/import.js';
 import checkKeyType from './check_key_type.js';
 import isObject from './is_object.js';
-async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
+async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options) {
     checkKeyType(alg, key, 'decrypt');
     switch (alg) {
         case 'dir': {
@@ -63,6 +63,9 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
                 throw new JWEInvalid('JWE Encrypted Key missing');
             if (typeof joseHeader.p2c !== 'number')
                 throw new 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 JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
             if (typeof joseHeader.p2s !== 'string')
                 throw new JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
             return pbes2Kw(alg, key, encryptedKey, joseHeader.p2c, base64url(joseHeader.p2s));

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

@@ -15,7 +15,7 @@ async function compactDecrypt(jwe, key, options) {
     if (length !== 5) {
         throw new errors_js_1.JWEInvalid('Invalid Compact JWE');
     }
-    const decrypted = await (0, decrypt_js_1.default)({
+    const decrypted = await decrypt_js_1.default({
         ciphertext: (ciphertext || undefined),
         iv: (iv || undefined),
         protected: protectedHeader || undefined,

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

@@ -14,7 +14,7 @@ const validate_crit_js_1 = require("../../lib/validate_crit.js");
 const validate_algorithms_js_1 = require("../../lib/validate_algorithms.js");
 async function flattenedDecrypt(jwe, key, options) {
     var _a;
-    if (!(0, is_object_js_1.default)(jwe)) {
+    if (!is_object_js_1.default(jwe)) {
         throw new errors_js_1.JWEInvalid('Flattened JWE must be an object');
     }
     if (jwe.protected === undefined && jwe.header === undefined && jwe.unprotected === undefined) {
@@ -38,15 +38,15 @@ async function flattenedDecrypt(jwe, key, options) {
     if (jwe.aad !== undefined && typeof jwe.aad !== 'string') {
         throw new errors_js_1.JWEInvalid('JWE AAD incorrect type');
     }
-    if (jwe.header !== undefined && !(0, is_object_js_1.default)(jwe.header)) {
+    if (jwe.header !== undefined && !is_object_js_1.default(jwe.header)) {
         throw new errors_js_1.JWEInvalid('JWE Shared Unprotected Header incorrect type');
     }
-    if (jwe.unprotected !== undefined && !(0, is_object_js_1.default)(jwe.unprotected)) {
+    if (jwe.unprotected !== undefined && !is_object_js_1.default(jwe.unprotected)) {
         throw new errors_js_1.JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
     }
     let parsedProt;
     if (jwe.protected) {
-        const protectedHeader = (0, base64url_js_1.decode)(jwe.protected);
+        const protectedHeader = base64url_js_1.decode(jwe.protected);
         try {
             parsedProt = JSON.parse(buffer_utils_js_1.decoder.decode(protectedHeader));
         }
@@ -54,7 +54,7 @@ async function flattenedDecrypt(jwe, key, options) {
             throw new errors_js_1.JWEInvalid('JWE Protected Header is invalid');
         }
     }
-    if (!(0, is_disjoint_js_1.default)(parsedProt, jwe.header, jwe.unprotected)) {
+    if (!is_disjoint_js_1.default(parsedProt, jwe.header, jwe.unprotected)) {
         throw new errors_js_1.JWEInvalid('JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint');
     }
     const joseHeader = {
@@ -62,7 +62,7 @@ async function flattenedDecrypt(jwe, key, options) {
         ...jwe.header,
         ...jwe.unprotected,
     };
-    (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, new Map(), options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader);
+    validate_crit_js_1.default(errors_js_1.JWEInvalid, new Map(), options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader);
     if (joseHeader.zip !== undefined) {
         if (!parsedProt || !parsedProt.zip) {
             throw new errors_js_1.JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
@@ -78,9 +78,9 @@ async function flattenedDecrypt(jwe, key, options) {
     if (typeof enc !== 'string' || !enc) {
         throw new errors_js_1.JWEInvalid('missing JWE Encryption Algorithm (enc) in JWE Header');
     }
-    const keyManagementAlgorithms = options && (0, validate_algorithms_js_1.default)('keyManagementAlgorithms', options.keyManagementAlgorithms);
+    const keyManagementAlgorithms = options && validate_algorithms_js_1.default('keyManagementAlgorithms', options.keyManagementAlgorithms);
     const contentEncryptionAlgorithms = options &&
-        (0, validate_algorithms_js_1.default)('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms);
+        validate_algorithms_js_1.default('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms);
     if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg)) {
         throw new errors_js_1.JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed');
     }
@@ -89,7 +89,7 @@ async function flattenedDecrypt(jwe, key, options) {
     }
     let encryptedKey;
     if (jwe.encrypted_key !== undefined) {
-        encryptedKey = (0, base64url_js_1.decode)(jwe.encrypted_key);
+        encryptedKey = base64url_js_1.decode(jwe.encrypted_key);
     }
     let resolvedKey = false;
     if (typeof key === 'function') {
@@ -98,25 +98,25 @@ async function flattenedDecrypt(jwe, key, options) {
     }
     let cek;
     try {
-        cek = await (0, decrypt_key_management_js_1.default)(alg, key, encryptedKey, joseHeader);
+        cek = await decrypt_key_management_js_1.default(alg, key, encryptedKey, joseHeader, options);
     }
     catch (err) {
-        if (err instanceof TypeError) {
+        if (err instanceof TypeError || err instanceof errors_js_1.JWEInvalid || err instanceof errors_js_1.JOSENotSupported) {
             throw err;
         }
-        cek = (0, cek_js_1.default)(enc);
+        cek = cek_js_1.default(enc);
     }
-    const iv = (0, base64url_js_1.decode)(jwe.iv);
-    const tag = (0, base64url_js_1.decode)(jwe.tag);
+    const iv = base64url_js_1.decode(jwe.iv);
+    const tag = base64url_js_1.decode(jwe.tag);
     const protectedHeader = buffer_utils_js_1.encoder.encode((_a = jwe.protected) !== null && _a !== void 0 ? _a : '');
     let additionalData;
     if (jwe.aad !== undefined) {
-        additionalData = (0, buffer_utils_js_1.concat)(protectedHeader, buffer_utils_js_1.encoder.encode('.'), buffer_utils_js_1.encoder.encode(jwe.aad));
+        additionalData = buffer_utils_js_1.concat(protectedHeader, buffer_utils_js_1.encoder.encode('.'), buffer_utils_js_1.encoder.encode(jwe.aad));
     }
     else {
         additionalData = protectedHeader;
     }
-    let plaintext = await (0, decrypt_js_1.default)(enc, cek, (0, base64url_js_1.decode)(jwe.ciphertext), iv, tag, additionalData);
+    let plaintext = await decrypt_js_1.default(enc, cek, base64url_js_1.decode(jwe.ciphertext), iv, tag, additionalData);
     if (joseHeader.zip === 'DEF') {
         plaintext = await ((options === null || options === void 0 ? void 0 : options.inflateRaw) || zlib_js_1.inflate)(plaintext);
     }
@@ -125,7 +125,7 @@ async function flattenedDecrypt(jwe, key, options) {
         result.protectedHeader = parsedProt;
     }
     if (jwe.aad !== undefined) {
-        result.additionalAuthenticatedData = (0, base64url_js_1.decode)(jwe.aad);
+        result.additionalAuthenticatedData = base64url_js_1.decode(jwe.aad);
     }
     if (jwe.unprotected !== undefined) {
         result.sharedUnprotectedHeader = jwe.unprotected;

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

@@ -67,7 +67,7 @@ class FlattenedEncrypt {
         if (!this._protectedHeader && !this._unprotectedHeader && !this._sharedUnprotectedHeader) {
             throw new errors_js_1.JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
         }
-        if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) {
+        if (!is_disjoint_js_1.default(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) {
             throw new errors_js_1.JWEInvalid('JWE Shared Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
         }
         const joseHeader = {
@@ -75,7 +75,7 @@ class FlattenedEncrypt {
             ...this._unprotectedHeader,
             ...this._sharedUnprotectedHeader,
         };
-        (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, new Map(), options === null || options === void 0 ? void 0 : options.crit, this._protectedHeader, joseHeader);
+        validate_crit_js_1.default(errors_js_1.JWEInvalid, new Map(), options === null || options === void 0 ? void 0 : options.crit, this._protectedHeader, joseHeader);
         if (joseHeader.zip !== undefined) {
             if (!this._protectedHeader || !this._protectedHeader.zip) {
                 throw new errors_js_1.JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
@@ -105,7 +105,7 @@ class FlattenedEncrypt {
         let cek;
         {
             let parameters;
-            ({ cek, encryptedKey, parameters } = await (0, encrypt_key_management_js_1.default)(alg, enc, key, this._cek, this._keyManagementParameters));
+            ({ cek, encryptedKey, parameters } = await encrypt_key_management_js_1.default(alg, enc, key, this._cek, this._keyManagementParameters));
             if (parameters) {
                 if (!this._protectedHeader) {
                     this.setProtectedHeader(parameters);
@@ -115,19 +115,19 @@ class FlattenedEncrypt {
                 }
             }
         }
-        this._iv || (this._iv = (0, iv_js_1.default)(enc));
+        this._iv || (this._iv = iv_js_1.default(enc));
         let additionalData;
         let protectedHeader;
         let aadMember;
         if (this._protectedHeader) {
-            protectedHeader = buffer_utils_js_1.encoder.encode((0, base64url_js_1.encode)(JSON.stringify(this._protectedHeader)));
+            protectedHeader = buffer_utils_js_1.encoder.encode(base64url_js_1.encode(JSON.stringify(this._protectedHeader)));
         }
         else {
             protectedHeader = buffer_utils_js_1.encoder.encode('');
         }
         if (this._aad) {
-            aadMember = (0, base64url_js_1.encode)(this._aad);
-            additionalData = (0, buffer_utils_js_1.concat)(protectedHeader, buffer_utils_js_1.encoder.encode('.'), buffer_utils_js_1.encoder.encode(aadMember));
+            aadMember = base64url_js_1.encode(this._aad);
+            additionalData = buffer_utils_js_1.concat(protectedHeader, buffer_utils_js_1.encoder.encode('.'), buffer_utils_js_1.encoder.encode(aadMember));
         }
         else {
             additionalData = protectedHeader;
@@ -136,19 +136,19 @@ class FlattenedEncrypt {
         let tag;
         if (joseHeader.zip === 'DEF') {
             const deflated = await ((options === null || options === void 0 ? void 0 : options.deflateRaw) || zlib_js_1.deflate)(this._plaintext);
-            ({ ciphertext, tag } = await (0, encrypt_js_1.default)(enc, deflated, cek, this._iv, additionalData));
+            ({ ciphertext, tag } = await encrypt_js_1.default(enc, deflated, cek, this._iv, additionalData));
         }
         else {
             ;
-            ({ ciphertext, tag } = await (0, encrypt_js_1.default)(enc, this._plaintext, cek, this._iv, additionalData));
+            ({ ciphertext, tag } = await encrypt_js_1.default(enc, this._plaintext, cek, this._iv, additionalData));
         }
         const jwe = {
-            ciphertext: (0, base64url_js_1.encode)(ciphertext),
-            iv: (0, base64url_js_1.encode)(this._iv),
-            tag: (0, base64url_js_1.encode)(tag),
+            ciphertext: base64url_js_1.encode(ciphertext),
+            iv: base64url_js_1.encode(this._iv),
+            tag: base64url_js_1.encode(tag),
         };
         if (encryptedKey) {
-            jwe.encrypted_key = (0, base64url_js_1.encode)(encryptedKey);
+            jwe.encrypted_key = base64url_js_1.encode(encryptedKey);
         }
         if (aadMember) {
             jwe.aad = aadMember;

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

@@ -5,7 +5,7 @@ const decrypt_js_1 = require("../flattened/decrypt.js");
 const errors_js_1 = require("../../util/errors.js");
 const is_object_js_1 = require("../../lib/is_object.js");
 async function generalDecrypt(jwe, key, options) {
-    if (!(0, is_object_js_1.default)(jwe)) {
+    if (!is_object_js_1.default(jwe)) {
         throw new errors_js_1.JWEInvalid('General JWE must be an object');
     }
     if (!Array.isArray(jwe.recipients) || !jwe.recipients.every(is_object_js_1.default)) {
@@ -13,7 +13,7 @@ async function generalDecrypt(jwe, key, options) {
     }
     for (const recipient of jwe.recipients) {
         try {
-            return await (0, decrypt_js_1.default)({
+            return await decrypt_js_1.default({
                 aad: jwe.aad,
                 ciphertext: jwe.ciphertext,
                 encrypted_key: recipient.encrypted_key,

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

@@ -9,10 +9,10 @@ async function EmbeddedJWK(protectedHeader, token) {
         ...protectedHeader,
         ...token.header,
     };
-    if (!(0, is_object_js_1.default)(joseHeader.jwk)) {
+    if (!is_object_js_1.default(joseHeader.jwk)) {
         throw new errors_js_1.JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a JSON object');
     }
-    const key = await (0, import_js_1.importJWK)({ ...joseHeader.jwk, ext: true }, joseHeader.alg, true);
+    const key = await import_js_1.importJWK({ ...joseHeader.jwk, ext: true }, joseHeader.alg, true);
     if (key instanceof Uint8Array || key.type !== 'public') {
         throw new errors_js_1.JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a public key');
     }

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromKeyLike = void 0;
 const export_js_1 = require("../key/export.js");
 async function fromKeyLike(key) {
-    return (0, export_js_1.exportJWK)(key);
+    return export_js_1.exportJWK(key);
 }
 exports.fromKeyLike = fromKeyLike;
 exports.default = fromKeyLike;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJwk = void 0;
 const import_js_1 = require("../key/import.js");
 async function parseJwk(jwk, alg, octAsKeyObject) {
-    return (0, import_js_1.importJWK)(jwk, alg, octAsKeyObject);
+    return import_js_1.importJWK(jwk, alg, octAsKeyObject);
 }
 exports.parseJwk = parseJwk;
 exports.default = parseJwk;

package/dist/node/cjs/jwk/thumbprint.js

@@ -12,7 +12,7 @@ const check = (value, description) => {
     }
 };
 async function calculateThumbprint(jwk, digestAlgorithm = 'sha256') {
-    if (!(0, is_object_js_1.default)(jwk)) {
+    if (!is_object_js_1.default(jwk)) {
         throw new TypeError('JWK must be an object');
     }
     let components;
@@ -41,7 +41,7 @@ async function calculateThumbprint(jwk, digestAlgorithm = 'sha256') {
             throw new errors_js_1.JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
     }
     const data = buffer_utils_js_1.encoder.encode(JSON.stringify(components));
-    return (0, base64url_js_1.encode)(await (0, digest_js_1.default)(digestAlgorithm, data));
+    return base64url_js_1.encode(await digest_js_1.default(digestAlgorithm, data));
 }
 exports.calculateThumbprint = calculateThumbprint;
 exports.default = calculateThumbprint;

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

@@ -19,7 +19,7 @@ function getKtyFromAlg(alg) {
     }
 }
 function isJWKLike(key) {
-    return (0, is_object_js_1.default)(key);
+    return is_object_js_1.default(key);
 }
 class RemoteJWKSet {
     constructor(url, options) {
@@ -93,7 +93,7 @@ class RemoteJWKSet {
         }
         const cached = this._cached.get(jwk) || this._cached.set(jwk, {}).get(jwk);
         if (cached[protectedHeader.alg] === undefined) {
-            const keyObject = await (0, import_js_1.importJWK)({ ...jwk, ext: true }, protectedHeader.alg);
+            const keyObject = await import_js_1.importJWK({ ...jwk, ext: true }, protectedHeader.alg);
             if (keyObject instanceof Uint8Array || keyObject.type !== 'public') {
                 throw new errors_js_1.JWKSInvalid('JSON Web Key Set members must be public keys');
             }
@@ -103,7 +103,7 @@ class RemoteJWKSet {
     }
     async reload() {
         if (!this._pendingFetch) {
-            this._pendingFetch = (0, fetch_jwks_js_1.default)(this._url, this._timeoutDuration, this._options)
+            this._pendingFetch = fetch_jwks_js_1.default(this._url, this._timeoutDuration, this._options)
                 .then((json) => {
                 if (typeof json !== 'object' ||
                     !json ||

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

@@ -15,7 +15,7 @@ async function compactVerify(jws, key, options) {
     if (length !== 3) {
         throw new errors_js_1.JWSInvalid('Invalid Compact JWS');
     }
-    const verified = await (0, verify_js_1.default)({
+    const verified = await verify_js_1.default({
         payload: (payload || undefined),
         protected: protectedHeader || undefined,
         signature: (signature || undefined),

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

@@ -33,14 +33,14 @@ class FlattenedSign {
         if (!this._protectedHeader && !this._unprotectedHeader) {
             throw new errors_js_1.JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()');
         }
-        if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader)) {
+        if (!is_disjoint_js_1.default(this._protectedHeader, this._unprotectedHeader)) {
             throw new errors_js_1.JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
         }
         const joseHeader = {
             ...this._protectedHeader,
             ...this._unprotectedHeader,
         };
-        const extensions = (0, validate_crit_js_1.default)(errors_js_1.JWSInvalid, new Map([['b64', true]]), options === null || options === void 0 ? void 0 : options.crit, this._protectedHeader, joseHeader);
+        const extensions = validate_crit_js_1.default(errors_js_1.JWSInvalid, new Map([['b64', true]]), options === null || options === void 0 ? void 0 : options.crit, this._protectedHeader, joseHeader);
         let b64 = true;
         if (extensions.has('b64')) {
             b64 = this._protectedHeader.b64;
@@ -52,22 +52,22 @@ class FlattenedSign {
         if (typeof alg !== 'string' || !alg) {
             throw new errors_js_1.JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
         }
-        (0, check_key_type_js_1.default)(alg, key, 'sign');
+        check_key_type_js_1.default(alg, key, 'sign');
         let payload = this._payload;
         if (b64) {
-            payload = buffer_utils_js_1.encoder.encode((0, base64url_js_1.encode)(payload));
+            payload = buffer_utils_js_1.encoder.encode(base64url_js_1.encode(payload));
         }
         let protectedHeader;
         if (this._protectedHeader) {
-            protectedHeader = buffer_utils_js_1.encoder.encode((0, base64url_js_1.encode)(JSON.stringify(this._protectedHeader)));
+            protectedHeader = buffer_utils_js_1.encoder.encode(base64url_js_1.encode(JSON.stringify(this._protectedHeader)));
         }
         else {
             protectedHeader = buffer_utils_js_1.encoder.encode('');
         }
-        const data = (0, buffer_utils_js_1.concat)(protectedHeader, buffer_utils_js_1.encoder.encode('.'), payload);
-        const signature = await (0, sign_js_1.default)(alg, key, data);
+        const data = buffer_utils_js_1.concat(protectedHeader, buffer_utils_js_1.encoder.encode('.'), payload);
+        const signature = await sign_js_1.default(alg, key, data);
         const jws = {
-            signature: (0, base64url_js_1.encode)(signature),
+            signature: base64url_js_1.encode(signature),
             payload: '',
         };
         if (b64) {

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

@@ -12,7 +12,7 @@ const validate_crit_js_1 = require("../../lib/validate_crit.js");
 const validate_algorithms_js_1 = require("../../lib/validate_algorithms.js");
 async function flattenedVerify(jws, key, options) {
     var _a;
-    if (!(0, is_object_js_1.default)(jws)) {
+    if (!is_object_js_1.default(jws)) {
         throw new errors_js_1.JWSInvalid('Flattened JWS must be an object');
     }
     if (jws.protected === undefined && jws.header === undefined) {
@@ -27,12 +27,12 @@ async function flattenedVerify(jws, key, options) {
     if (typeof jws.signature !== 'string') {
         throw new errors_js_1.JWSInvalid('JWS Signature missing or incorrect type');
     }
-    if (jws.header !== undefined && !(0, is_object_js_1.default)(jws.header)) {
+    if (jws.header !== undefined && !is_object_js_1.default(jws.header)) {
         throw new errors_js_1.JWSInvalid('JWS Unprotected Header incorrect type');
     }
     let parsedProt = {};
     if (jws.protected) {
-        const protectedHeader = (0, base64url_js_1.decode)(jws.protected);
+        const protectedHeader = base64url_js_1.decode(jws.protected);
         try {
             parsedProt = JSON.parse(buffer_utils_js_1.decoder.decode(protectedHeader));
         }
@@ -40,14 +40,14 @@ async function flattenedVerify(jws, key, options) {
             throw new errors_js_1.JWSInvalid('JWS Protected Header is invalid');
         }
     }
-    if (!(0, is_disjoint_js_1.default)(parsedProt, jws.header)) {
+    if (!is_disjoint_js_1.default(parsedProt, jws.header)) {
         throw new errors_js_1.JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
     }
     const joseHeader = {
         ...parsedProt,
         ...jws.header,
     };
-    const extensions = (0, validate_crit_js_1.default)(errors_js_1.JWSInvalid, new Map([['b64', true]]), options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader);
+    const extensions = validate_crit_js_1.default(errors_js_1.JWSInvalid, new Map([['b64', true]]), options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader);
     let b64 = true;
     if (extensions.has('b64')) {
         b64 = parsedProt.b64;
@@ -59,7 +59,7 @@ async function flattenedVerify(jws, key, options) {
     if (typeof alg !== 'string' || !alg) {
         throw new errors_js_1.JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
     }
-    const algorithms = options && (0, validate_algorithms_js_1.default)('algorithms', options.algorithms);
+    const algorithms = options && validate_algorithms_js_1.default('algorithms', options.algorithms);
     if (algorithms && !algorithms.has(alg)) {
         throw new errors_js_1.JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed');
     }
@@ -76,16 +76,16 @@ async function flattenedVerify(jws, key, options) {
         key = await key(parsedProt, jws);
         resolvedKey = true;
     }
-    (0, check_key_type_js_1.default)(alg, key, 'verify');
-    const data = (0, buffer_utils_js_1.concat)(buffer_utils_js_1.encoder.encode((_a = jws.protected) !== null && _a !== void 0 ? _a : ''), buffer_utils_js_1.encoder.encode('.'), typeof jws.payload === 'string' ? buffer_utils_js_1.encoder.encode(jws.payload) : jws.payload);
-    const signature = (0, base64url_js_1.decode)(jws.signature);
-    const verified = await (0, verify_js_1.default)(alg, key, signature, data);
+    check_key_type_js_1.default(alg, key, 'verify');
+    const data = buffer_utils_js_1.concat(buffer_utils_js_1.encoder.encode((_a = jws.protected) !== null && _a !== void 0 ? _a : ''), buffer_utils_js_1.encoder.encode('.'), typeof jws.payload === 'string' ? buffer_utils_js_1.encoder.encode(jws.payload) : jws.payload);
+    const signature = base64url_js_1.decode(jws.signature);
+    const verified = await verify_js_1.default(alg, key, signature, data);
     if (!verified) {
         throw new errors_js_1.JWSSignatureVerificationFailed();
     }
     let payload;
     if (b64) {
-        payload = (0, base64url_js_1.decode)(jws.payload);
+        payload = base64url_js_1.decode(jws.payload);
     }
     else if (typeof jws.payload === 'string') {
         payload = buffer_utils_js_1.encoder.encode(jws.payload);

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

@@ -5,7 +5,7 @@ const verify_js_1 = require("../flattened/verify.js");
 const errors_js_1 = require("../../util/errors.js");
 const is_object_js_1 = require("../../lib/is_object.js");
 async function generalVerify(jws, key, options) {
-    if (!(0, is_object_js_1.default)(jws)) {
+    if (!is_object_js_1.default(jws)) {
         throw new errors_js_1.JWSInvalid('General JWS must be an object');
     }
     if (!Array.isArray(jws.signatures) || !jws.signatures.every(is_object_js_1.default)) {
@@ -13,7 +13,7 @@ async function generalVerify(jws, key, options) {
     }
     for (const signature of jws.signatures) {
         try {
-            return await (0, verify_js_1.default)({
+            return await verify_js_1.default({
                 header: signature.header,
                 payload: jws.payload,
                 protected: signature.protected,

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

@@ -5,8 +5,8 @@ const decrypt_js_1 = require("../jwe/compact/decrypt.js");
 const jwt_claims_set_js_1 = require("../lib/jwt_claims_set.js");
 const errors_js_1 = require("../util/errors.js");
 async function jwtDecrypt(jwt, key, options) {
-    const decrypted = await (0, decrypt_js_1.default)(jwt, key, options);
-    const payload = (0, jwt_claims_set_js_1.default)(decrypted.protectedHeader, decrypted.plaintext, options);
+    const decrypted = await decrypt_js_1.default(jwt, key, options);
+    const payload = jwt_claims_set_js_1.default(decrypted.protectedHeader, decrypted.plaintext, options);
     const { protectedHeader } = decrypted;
     if (protectedHeader.iss !== undefined && protectedHeader.iss !== payload.iss) {
         throw new errors_js_1.JWTClaimValidationFailed('replicated "iss" claim header parameter mismatch', 'iss', 'mismatch');

package/dist/node/cjs/jwt/produce.js

@@ -6,7 +6,7 @@ const is_object_js_1 = require("../lib/is_object.js");
 const secs_js_1 = require("../lib/secs.js");
 class ProduceJWT {
     constructor(payload) {
-        if (!(0, is_object_js_1.default)(payload)) {
+        if (!is_object_js_1.default(payload)) {
             throw new TypeError('JWT Claims Set MUST be an object');
         }
         this._payload = payload;
@@ -32,7 +32,7 @@ class ProduceJWT {
             this._payload = { ...this._payload, nbf: input };
         }
         else {
-            this._payload = { ...this._payload, nbf: (0, epoch_js_1.default)(new Date()) + (0, secs_js_1.default)(input) };
+            this._payload = { ...this._payload, nbf: epoch_js_1.default(new Date()) + secs_js_1.default(input) };
         }
         return this;
     }
@@ -41,13 +41,13 @@ class ProduceJWT {
             this._payload = { ...this._payload, exp: input };
         }
         else {
-            this._payload = { ...this._payload, exp: (0, epoch_js_1.default)(new Date()) + (0, secs_js_1.default)(input) };
+            this._payload = { ...this._payload, exp: epoch_js_1.default(new Date()) + secs_js_1.default(input) };
         }
         return this;
     }
     setIssuedAt(input) {
         if (typeof input === 'undefined') {
-            this._payload = { ...this._payload, iat: (0, epoch_js_1.default)(new Date()) };
+            this._payload = { ...this._payload, iat: epoch_js_1.default(new Date()) };
         }
         else {
             this._payload = { ...this._payload, iat: input };

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

@@ -29,7 +29,7 @@ class UnsecuredJWT extends produce_js_1.ProduceJWT {
         catch {
             throw new errors_js_1.JWTInvalid('Invalid Unsecured JWT');
         }
-        const payload = (0, jwt_claims_set_js_1.default)(header, base64url.decode(encodedPayload), options);
+        const payload = jwt_claims_set_js_1.default(header, base64url.decode(encodedPayload), options);
         return { payload, header };
     }
 }

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

@@ -6,11 +6,11 @@ const jwt_claims_set_js_1 = require("../lib/jwt_claims_set.js");
 const errors_js_1 = require("../util/errors.js");
 async function jwtVerify(jwt, key, options) {
     var _a;
-    const verified = await (0, verify_js_1.default)(jwt, key, options);
+    const verified = await verify_js_1.default(jwt, key, options);
     if (((_a = verified.protectedHeader.crit) === null || _a === void 0 ? void 0 : _a.includes('b64')) && verified.protectedHeader.b64 === false) {
         throw new errors_js_1.JWTInvalid('JWTs MUST NOT use unencoded payload');
     }
-    const payload = (0, jwt_claims_set_js_1.default)(verified.protectedHeader, verified.payload, options);
+    const payload = jwt_claims_set_js_1.default(verified.protectedHeader, verified.payload, options);
     const result = { payload, protectedHeader: verified.protectedHeader };
     if (typeof key === 'function') {
         return { ...result, key: verified.key };

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

@@ -5,14 +5,14 @@ const asn1_js_1 = require("../runtime/asn1.js");
 const asn1_js_2 = require("../runtime/asn1.js");
 const key_to_jwk_js_1 = require("../runtime/key_to_jwk.js");
 async function exportSPKI(key) {
-    return (0, asn1_js_1.toSPKI)(key);
+    return asn1_js_1.toSPKI(key);
 }
 exports.exportSPKI = exportSPKI;
 async function exportPKCS8(key) {
-    return (0, asn1_js_2.toPKCS8)(key);
+    return asn1_js_2.toPKCS8(key);
 }
 exports.exportPKCS8 = exportPKCS8;
 async function exportJWK(key) {
-    return (0, key_to_jwk_js_1.default)(key);
+    return key_to_jwk_js_1.default(key);
 }
 exports.exportJWK = exportJWK;

package/dist/node/cjs/key/import.js

@@ -65,18 +65,18 @@ function parseElement(bytes) {
     };
 }
 function spkiFromX509(buf) {
-    return (0, base64url_js_1.encodeBase64)(getElement(getElement(parseElement(buf).contents)[0].contents)[6].raw);
+    return base64url_js_1.encodeBase64(getElement(getElement(parseElement(buf).contents)[0].contents)[6].raw);
 }
 function getSPKI(x509) {
     const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');
-    const raw = (0, base64url_js_1.decodeBase64)(pem);
-    return (0, format_pem_js_1.default)(spkiFromX509(raw), 'PUBLIC KEY');
+    const raw = base64url_js_1.decodeBase64(pem);
+    return format_pem_js_1.default(spkiFromX509(raw), 'PUBLIC KEY');
 }
 async function importSPKI(spki, alg, options) {
     if (typeof spki !== 'string' || spki.indexOf('-----BEGIN PUBLIC KEY-----') !== 0) {
         throw new TypeError('"spki" must be SPKI formatted string');
     }
-    return (0, asn1_js_1.fromSPKI)(spki, alg, options);
+    return asn1_js_1.fromSPKI(spki, alg, options);
 }
 exports.importSPKI = importSPKI;
 async function importX509(x509, alg, options) {
@@ -84,18 +84,18 @@ async function importX509(x509, alg, options) {
         throw new TypeError('"x509" must be X.509 formatted string');
     }
     const spki = getSPKI(x509);
-    return (0, asn1_js_1.fromSPKI)(spki, alg, options);
+    return asn1_js_1.fromSPKI(spki, alg, options);
 }
 exports.importX509 = importX509;
 async function importPKCS8(pkcs8, alg, options) {
     if (typeof pkcs8 !== 'string' || pkcs8.indexOf('-----BEGIN PRIVATE KEY-----') !== 0) {
         throw new TypeError('"pkcs8" must be PCKS8 formatted string');
     }
-    return (0, asn1_js_2.fromPKCS8)(pkcs8, alg, options);
+    return asn1_js_2.fromPKCS8(pkcs8, alg, options);
 }
 exports.importPKCS8 = importPKCS8;
 async function importJWK(jwk, alg, octAsKeyObject) {
-    if (!(0, is_object_js_1.default)(jwk)) {
+    if (!is_object_js_1.default(jwk)) {
         throw new TypeError('JWK must be an object');
     }
     alg || (alg = jwk.alg);
@@ -109,16 +109,16 @@ async function importJWK(jwk, alg, octAsKeyObject) {
             }
             octAsKeyObject !== null && octAsKeyObject !== void 0 ? octAsKeyObject : (octAsKeyObject = jwk.ext !== true);
             if (octAsKeyObject) {
-                return (0, jwk_to_key_js_1.default)({ ...jwk, alg, ext: false });
+                return jwk_to_key_js_1.default({ ...jwk, alg, ext: false });
             }
-            return (0, base64url_js_1.decode)(jwk.k);
+            return base64url_js_1.decode(jwk.k);
         case 'RSA':
             if (jwk.oth !== undefined) {
                 throw new errors_js_1.JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
             }
         case 'EC':
         case 'OKP':
-            return (0, jwk_to_key_js_1.default)({ ...jwk, alg });
+            return jwk_to_key_js_1.default({ ...jwk, alg });
         default:
             throw new errors_js_1.JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
     }

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

@@ -17,6 +17,6 @@ const generateCek = (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 = generateCek;