@zuplo/cli 6.73.27 → 6.73.28

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/content_encryption.js

@@ -1,52 +1,18 @@
 import { concat, uint64be } from './buffer_utils.js';
-import { checkEncCryptoKey } from './crypto_key.js';
+import { checkCryptoKey } from './crypto_key.js';
 import { invalidKeyInput } from './invalid_key_input.js';
-import { JOSENotSupported, JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
+import { JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
 import { isCryptoKey } from './is_key_like.js';
-export function cekLength(alg) {
-    switch (alg) {
-        case 'A128GCM':
-            return 128;
-        case 'A192GCM':
-            return 192;
-        case 'A256GCM':
-        case 'A128CBC-HS256':
-            return 256;
-        case 'A192CBC-HS384':
-            return 384;
-        case 'A256CBC-HS512':
-            return 512;
-        default:
-            throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
-    }
-}
-export const generateCek = (alg) => crypto.getRandomValues(new Uint8Array(cekLength(alg) >> 3));
+export const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
 function checkCekLength(cek, expected) {
     const actual = cek.byteLength << 3;
     if (actual !== expected) {
         throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
     }
 }
-function ivBitLength(alg) {
-    switch (alg) {
-        case 'A128GCM':
-        case 'A128GCMKW':
-        case 'A192GCM':
-        case 'A192GCMKW':
-        case 'A256GCM':
-        case 'A256GCMKW':
-            return 96;
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            return 128;
-        default:
-            throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
-    }
-}
-export const generateIv = (alg) => crypto.getRandomValues(new Uint8Array(ivBitLength(alg) >> 3));
+export const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
 export function checkIvLength(enc, iv) {
-    if (iv.length << 3 !== ivBitLength(enc)) {
+    if (iv.length << 3 !== enc.ivBits) {
         throw new JWEInvalid('Invalid Initialization Vector length');
     }
 }
@@ -54,7 +20,7 @@ async function cbcKeySetup(enc, cek, usage) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
     }
-    const keySize = parseInt(enc.slice(1, 4), 10);
+    const keySize = enc.cekBits >> 1;
     const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, [usage]);
     const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
         hash: `SHA-${keySize << 1}`,
@@ -71,7 +37,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
         iv: iv,
         name: 'AES-CBC',
     }, encKey, plaintext));
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
+    const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
     const tag = await cbcHmacTag(macKey, macData, keySize);
     return { ciphertext, tag, iv };
 }
@@ -95,7 +61,7 @@ async function timingSafeEqual(a, b) {
 }
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const { encKey, macKey, keySize } = await cbcKeySetup(enc, cek, 'decrypt');
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
+    const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
     const expectedTag = await cbcHmacTag(macKey, macData, keySize);
     let macCheckPassed;
     try {
@@ -123,7 +89,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
         encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt']);
     }
     else {
-        checkEncCryptoKey(cek, enc, 'encrypt');
+        checkCryptoKey(cek, enc.subtle, 'encrypt');
         encKey = cek;
     }
     const encrypted = new Uint8Array(await crypto.subtle.encrypt({
@@ -142,7 +108,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt']);
     }
     else {
-        checkEncCryptoKey(cek, enc, 'decrypt');
+        checkCryptoKey(cek, enc.subtle, 'decrypt');
         encKey = cek;
     }
     try {
@@ -157,7 +123,6 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new JWEDecryptionFailed();
     }
 }
-const unsupportedEnc = 'Unsupported JWE Content Encryption Algorithm';
 export async function encrypt(enc, plaintext, cek, iv, aad) {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
@@ -168,24 +133,12 @@ export async function encrypt(enc, plaintext, cek, iv, aad) {
     else {
         iv = generateIv(enc);
     }
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            if (cek instanceof Uint8Array) {
-                checkCekLength(cek, parseInt(enc.slice(-3), 10));
-            }
-            return cbcEncrypt(enc, plaintext, cek, iv, aad);
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            if (cek instanceof Uint8Array) {
-                checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
-            }
-            return gcmEncrypt(enc, plaintext, cek, iv, aad);
-        default:
-            throw new JOSENotSupported(unsupportedEnc);
+    if (cek instanceof Uint8Array) {
+        checkCekLength(cek, enc.cekBits);
     }
+    return enc.cbc
+        ? cbcEncrypt(enc, plaintext, cek, iv, aad)
+        : gcmEncrypt(enc, plaintext, cek, iv, aad);
 }
 export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
@@ -198,20 +151,10 @@ export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new JWEInvalid('JWE Authentication Tag missing');
     }
     checkIvLength(enc, iv);
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            if (cek instanceof Uint8Array)
-                checkCekLength(cek, parseInt(enc.slice(-3), 10));
-            return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad);
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            if (cek instanceof Uint8Array)
-                checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
-            return gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
-        default:
-            throw new JOSENotSupported(unsupportedEnc);
+    if (cek instanceof Uint8Array) {
+        checkCekLength(cek, enc.cekBits);
     }
+    return enc.cbc
+        ? cbcDecrypt(enc, cek, ciphertext, iv, tag, aad)
+        : gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
 }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/crypto_key.js

@@ -1,136 +1,22 @@
 const unusable = (name, prop = 'algorithm.name') => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-const isAlgorithm = (algorithm, name) => algorithm.name === name;
-function getHashLength(hash) {
-    return parseInt(hash.name.slice(4), 10);
-}
-function checkHashLength(algorithm, expected) {
-    const actual = getHashLength(algorithm.hash);
-    if (actual !== expected)
-        throw unusable(`SHA-${expected}`, 'algorithm.hash');
-}
-function getNamedCurve(alg) {
-    switch (alg) {
-        case 'ES256':
-            return 'P-256';
-        case 'ES384':
-            return 'P-384';
-        case 'ES512':
-            return 'P-521';
-        default:
-            throw new Error('unreachable');
-    }
-}
-function checkUsage(key, usage) {
+export function checkUsage(key, usage) {
     if (usage && !key.usages.includes(usage)) {
         throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
     }
 }
-export function checkSigCryptoKey(key, alg, usage) {
-    switch (alg) {
-        case 'HS256':
-        case 'HS384':
-        case 'HS512': {
-            if (!isAlgorithm(key.algorithm, 'HMAC'))
-                throw unusable('HMAC');
-            checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
-            break;
-        }
-        case 'RS256':
-        case 'RS384':
-        case 'RS512': {
-            if (!isAlgorithm(key.algorithm, 'RSASSA-PKCS1-v1_5'))
-                throw unusable('RSASSA-PKCS1-v1_5');
-            checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
-            break;
-        }
-        case 'PS256':
-        case 'PS384':
-        case 'PS512': {
-            if (!isAlgorithm(key.algorithm, 'RSA-PSS'))
-                throw unusable('RSA-PSS');
-            checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
-            break;
-        }
-        case 'Ed25519':
-        case 'EdDSA': {
-            if (!isAlgorithm(key.algorithm, 'Ed25519'))
-                throw unusable('Ed25519');
-            break;
-        }
-        case 'ML-DSA-44':
-        case 'ML-DSA-65':
-        case 'ML-DSA-87': {
-            if (!isAlgorithm(key.algorithm, alg))
-                throw unusable(alg);
-            break;
-        }
-        case 'ES256':
-        case 'ES384':
-        case 'ES512': {
-            if (!isAlgorithm(key.algorithm, 'ECDSA'))
-                throw unusable('ECDSA');
-            const expected = getNamedCurve(alg);
-            const actual = key.algorithm.namedCurve;
-            if (actual !== expected)
-                throw unusable(expected, 'algorithm.namedCurve');
-            break;
-        }
-        default:
-            throw new TypeError('CryptoKey does not support this operation');
+export function checkCryptoKey(key, expected, usage) {
+    const algorithm = key.algorithm;
+    if (algorithm.name !== expected.name) {
+        throw unusable(expected.name);
     }
-    checkUsage(key, usage);
-}
-export function checkEncCryptoKey(key, alg, usage) {
-    switch (alg) {
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM': {
-            if (!isAlgorithm(key.algorithm, 'AES-GCM'))
-                throw unusable('AES-GCM');
-            const expected = parseInt(alg.slice(1, 4), 10);
-            const actual = key.algorithm.length;
-            if (actual !== expected)
-                throw unusable(expected, 'algorithm.length');
-            break;
-        }
-        case 'A128KW':
-        case 'A192KW':
-        case 'A256KW': {
-            if (!isAlgorithm(key.algorithm, 'AES-KW'))
-                throw unusable('AES-KW');
-            const expected = parseInt(alg.slice(1, 4), 10);
-            const actual = key.algorithm.length;
-            if (actual !== expected)
-                throw unusable(expected, 'algorithm.length');
-            break;
-        }
-        case 'ECDH': {
-            switch (key.algorithm.name) {
-                case 'ECDH':
-                case 'X25519':
-                    break;
-                default:
-                    throw unusable('ECDH or X25519');
-            }
-            break;
-        }
-        case 'PBES2-HS256+A128KW':
-        case 'PBES2-HS384+A192KW':
-        case 'PBES2-HS512+A256KW':
-            if (!isAlgorithm(key.algorithm, 'PBKDF2'))
-                throw unusable('PBKDF2');
-            break;
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512': {
-            if (!isAlgorithm(key.algorithm, 'RSA-OAEP'))
-                throw unusable('RSA-OAEP');
-            checkHashLength(key.algorithm, parseInt(alg.slice(9), 10) || 1);
-            break;
-        }
-        default:
-            throw new TypeError('CryptoKey does not support this operation');
+    if (expected.hash && algorithm.hash?.name !== expected.hash) {
+        throw unusable(expected.hash, 'algorithm.hash');
+    }
+    if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve) {
+        throw unusable(expected.namedCurve, 'algorithm.namedCurve');
+    }
+    if (expected.length !== undefined && algorithm.length !== expected.length) {
+        throw unusable(expected.length, 'algorithm.length');
     }
     checkUsage(key, usage);
 }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/helpers.js

@@ -1,4 +1,6 @@
 import { decode } from '../util/base64url.js';
+import { encode, strictDecoder } from './buffer_utils.js';
+import { isObject } from './type_checks.js';
 export const unprotected = Symbol();
 export function assertNotSet(value, name) {
     if (value) {
@@ -13,7 +15,28 @@ export function decodeBase64url(value, label, ErrorClass) {
         throw new ErrorClass(`Failed to base64url decode the ${label}`);
     }
 }
+export function encodeBase64url(value, label, ErrorClass) {
+    try {
+        return encode(value);
+    }
+    catch {
+        throw new ErrorClass(`The ${label} is not a valid base64url string`);
+    }
+}
 export async function digest(algorithm, data) {
     const subtleDigest = `SHA-${algorithm.slice(-3)}`;
     return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
 }
+export function parseJoseHeader(b64, ErrorClass, message) {
+    let parsed;
+    try {
+        parsed = JSON.parse(strictDecoder.decode(decode(b64)));
+    }
+    catch {
+        throw new ErrorClass(message);
+    }
+    if (!isObject(parsed)) {
+        throw new ErrorClass(message);
+    }
+    return parsed;
+}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/jwe_algorithms.js

@@ -0,0 +1,143 @@
+import { JOSENotSupported } from '../util/errors.js';
+import { table } from './key_descriptor.js';
+const wrap = {
+    public: ['encrypt', 'wrapKey'],
+    private: ['decrypt', 'unwrapKey'],
+};
+const derive = { public: [], private: ['deriveBits'] };
+const none = { public: [], private: [] };
+function rsaes(bits) {
+    return {
+        kty: ['RSA'],
+        subtle: { name: 'RSA-OAEP', hash: `SHA-${bits}` },
+        usages: wrap,
+        minModulusLength: 2048,
+        keyOps: { encrypt: 'wrapKey', decrypt: 'unwrapKey' },
+    };
+}
+function ecdh(kwBits) {
+    return {
+        kty: ['EC', 'OKP'],
+        subtle: { name: 'ECDH' },
+        subtleFor: ({ kty, crv, asymmetricKeyType }) => {
+            if (crv === 'X25519' || asymmetricKeyType === 'x25519') {
+                return { name: 'X25519' };
+            }
+            if (kty === 'OKP') {
+                throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+            }
+            return { name: 'ECDH', namedCurve: crv };
+        },
+        usages: derive,
+        kwBits,
+        keyOps: { decrypt: 'deriveBits' },
+    };
+}
+function aeskw(bits) {
+    return {
+        kty: ['oct'],
+        symmetric: true,
+        subtle: { name: 'AES-KW', length: bits },
+        usages: none,
+        keyOps: { encrypt: 'wrapKey', decrypt: 'unwrapKey' },
+    };
+}
+function aesgcmkw(bits) {
+    return {
+        kty: ['oct'],
+        symmetric: true,
+        subtle: { name: 'AES-GCM', length: bits },
+        usages: none,
+        gcmkw: `A${bits}GCM`,
+        keyOps: { encrypt: 'encrypt', decrypt: 'decrypt' },
+    };
+}
+function pbes2(bits, kwBits) {
+    return {
+        kty: ['oct'],
+        symmetric: true,
+        subtle: { name: 'PBKDF2' },
+        usages: none,
+        pbes2Hash: `SHA-${bits}`,
+        kwBits,
+        keyOps: { encrypt: 'deriveBits', decrypt: 'deriveBits' },
+    };
+}
+const JWE = table({
+    dir: {
+        kty: ['oct'],
+        symmetric: true,
+        subtle: { name: 'AES-GCM' },
+        usages: none,
+        keyOps: { encrypt: 'encrypt', decrypt: 'decrypt' },
+    },
+    'RSA-OAEP': rsaes(1),
+    'RSA-OAEP-256': rsaes(256),
+    'RSA-OAEP-384': rsaes(384),
+    'RSA-OAEP-512': rsaes(512),
+    'ECDH-ES': ecdh(),
+    'ECDH-ES+A128KW': ecdh(128),
+    'ECDH-ES+A192KW': ecdh(192),
+    'ECDH-ES+A256KW': ecdh(256),
+    A128KW: aeskw(128),
+    A192KW: aeskw(192),
+    A256KW: aeskw(256),
+    A128GCMKW: aesgcmkw(128),
+    A192GCMKW: aesgcmkw(192),
+    A256GCMKW: aesgcmkw(256),
+    'PBES2-HS256+A128KW': pbes2(256, 128),
+    'PBES2-HS384+A192KW': pbes2(384, 192),
+    'PBES2-HS512+A256KW': pbes2(512, 256),
+});
+const content = { public: [], private: [] };
+const contentOps = { encrypt: 'encrypt', decrypt: 'decrypt' };
+function gcm(bits) {
+    return {
+        kty: ['oct'],
+        symmetric: true,
+        subtle: { name: 'AES-GCM', length: bits },
+        usages: content,
+        keyOps: contentOps,
+        cekBits: bits,
+        ivBits: 96,
+        cbc: false,
+    };
+}
+function cbc(bits) {
+    return {
+        kty: ['oct'],
+        symmetric: true,
+        subtle: { name: 'AES-CBC', length: bits },
+        usages: content,
+        keyOps: contentOps,
+        cekBits: bits,
+        ivBits: 128,
+        cbc: true,
+    };
+}
+const ENC = table({
+    A128GCM: gcm(128),
+    A192GCM: gcm(192),
+    A256GCM: gcm(256),
+    'A128CBC-HS256': cbc(256),
+    'A192CBC-HS384': cbc(384),
+    'A256CBC-HS512': cbc(512),
+});
+const unsupportedAlgHeader = 'Invalid or unsupported "alg" (JWE Algorithm) header value';
+export function jweAlgorithm(alg) {
+    const entry = JWE[alg];
+    if (!entry) {
+        throw new JOSENotSupported(unsupportedAlgHeader);
+    }
+    return entry;
+}
+export function maybeJWEAlgorithm(alg) {
+    return JWE[alg];
+}
+export function jweEncryption(enc) {
+    const entry = ENC[enc];
+    if (!entry) {
+        throw new JOSENotSupported(`Unsupported JWE Algorithm: ${enc}`);
+    }
+    return entry;
+}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/jwe_decrypt.js

@@ -0,0 +1,181 @@
+import { decrypt, generateCek } from './content_encryption.js';
+import { decodeBase64url, encodeBase64url, parseJoseHeader } from './helpers.js';
+import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from '../util/errors.js';
+import { isDisjoint, isObject } from './type_checks.js';
+import { decryptKeyManagement } from './key_management.js';
+import { concat, decoder, encode } from './buffer_utils.js';
+import { validateCrit, validateAlgorithms, JWE_RECOGNIZED } from './options.js';
+import { prepareKey } from './key.js';
+import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
+import { decompress } from './deflate.js';
+export function checkShared(jwe) {
+    if (jwe.iv !== undefined && typeof jwe.iv !== 'string') {
+        throw new JWEInvalid('JWE Initialization Vector incorrect type');
+    }
+    if (typeof jwe.ciphertext !== 'string') {
+        throw new JWEInvalid('JWE Ciphertext missing or incorrect type');
+    }
+    if (jwe.tag !== undefined && typeof jwe.tag !== 'string') {
+        throw new JWEInvalid('JWE Authentication Tag incorrect type');
+    }
+    if (jwe.protected !== undefined && typeof jwe.protected !== 'string') {
+        throw new JWEInvalid('JWE Protected Header incorrect type');
+    }
+    if (jwe.aad !== undefined && typeof jwe.aad !== 'string') {
+        throw new JWEInvalid('JWE AAD incorrect type');
+    }
+    if (jwe.unprotected !== undefined && !isObject(jwe.unprotected)) {
+        throw new JWEInvalid('JWE Shared Unprotected Header incorrect type');
+    }
+}
+export function checkRecipient(jwe) {
+    if (jwe.encrypted_key !== undefined && typeof jwe.encrypted_key !== 'string') {
+        throw new JWEInvalid('JWE Encrypted Key incorrect type');
+    }
+    if (jwe.header !== undefined && !isObject(jwe.header)) {
+        throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
+    }
+    if (jwe.protected === undefined && jwe.header === undefined && jwe.unprotected === undefined) {
+        throw new JWEInvalid('JOSE Header missing');
+    }
+}
+export function shareJWE(jwe) {
+    let parsedProt;
+    if (jwe.protected) {
+        parsedProt = parseJoseHeader(jwe.protected, JWEInvalid, 'JWE Protected Header is invalid');
+    }
+    const protectedHeader = jwe.protected !== undefined ? encode(jwe.protected) : new Uint8Array();
+    return {
+        parsedProt,
+        ciphertext: decodeBase64url(jwe.ciphertext, 'ciphertext', JWEInvalid),
+        iv: jwe.iv !== undefined ? decodeBase64url(jwe.iv, 'iv', JWEInvalid) : undefined,
+        tag: jwe.tag !== undefined ? decodeBase64url(jwe.tag, 'tag', JWEInvalid) : undefined,
+        additionalData: jwe.aad !== undefined
+            ? concat(protectedHeader, encode('.'), encodeBase64url(jwe.aad, 'aad', JWEInvalid))
+            : protectedHeader,
+    };
+}
+export function decryptResult(jwe, decrypted) {
+    const result = { plaintext: decrypted.plaintext };
+    if (jwe.protected !== undefined) {
+        result.protectedHeader = decrypted.parsedProt;
+    }
+    if (jwe.aad !== undefined) {
+        result.additionalAuthenticatedData = decodeBase64url(jwe.aad, 'aad', JWEInvalid);
+    }
+    if (jwe.unprotected !== undefined) {
+        result.sharedUnprotectedHeader = jwe.unprotected;
+    }
+    if (jwe.header !== undefined) {
+        result.unprotectedHeader = jwe.header;
+    }
+    if (decrypted.resolvedKey) {
+        return { ...result, key: decrypted.key };
+    }
+    return result;
+}
+export function prepareDecrypt(options) {
+    return {
+        keyManagementAlgorithms: options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms),
+        contentEncryptionAlgorithms: options &&
+            validateAlgorithms('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms),
+        options,
+    };
+}
+export async function decryptRecipient(jwe, token, shared, key) {
+    const { options } = shared;
+    const { parsedProt } = token;
+    let joseHeader;
+    if (jwe.header !== undefined || jwe.unprotected !== undefined) {
+        if (!isDisjoint(parsedProt, jwe.header, jwe.unprotected)) {
+            throw new JWEInvalid('JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint');
+        }
+        joseHeader = { ...parsedProt, ...jwe.header, ...jwe.unprotected };
+    }
+    else {
+        joseHeader = parsedProt ?? {};
+    }
+    validateCrit(JWEInvalid, JWE_RECOGNIZED, options?.crit, parsedProt, joseHeader);
+    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
+        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+    }
+    if (joseHeader.zip !== undefined && !parsedProt?.zip) {
+        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
+    }
+    const { alg, enc } = joseHeader;
+    if (typeof alg !== 'string' || !alg) {
+        throw new JWEInvalid('missing JWE Algorithm (alg) in JWE Header');
+    }
+    if (typeof enc !== 'string' || !enc) {
+        throw new JWEInvalid('missing JWE Encryption Algorithm (enc) in JWE Header');
+    }
+    const { keyManagementAlgorithms, contentEncryptionAlgorithms } = shared;
+    if ((keyManagementAlgorithms && !keyManagementAlgorithms.has(alg)) ||
+        (!keyManagementAlgorithms && alg.startsWith('PBES2'))) {
+        throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
+    }
+    if (contentEncryptionAlgorithms && !contentEncryptionAlgorithms.has(enc)) {
+        throw new JOSEAlgNotAllowed('"enc" (Encryption Algorithm) Header Parameter value not allowed');
+    }
+    const encEntry = jweEncryption(enc);
+    let encryptedKey;
+    if (jwe.encrypted_key !== undefined) {
+        encryptedKey = decodeBase64url(jwe.encrypted_key, 'encrypted_key', JWEInvalid);
+    }
+    let resolvedKey = false;
+    if (typeof key === 'function') {
+        key = await key(parsedProt, jwe);
+        resolvedKey = true;
+    }
+    const algEntry = jweAlgorithm(alg);
+    const k = await prepareKey(alg === 'dir' ? encEntry : algEntry, key, 'decrypt');
+    let cek;
+    try {
+        cek = await decryptKeyManagement(alg, encEntry, k, encryptedKey, joseHeader, options);
+    }
+    catch (err) {
+        if (err instanceof TypeError || err instanceof JWEInvalid || err instanceof JOSENotSupported) {
+            throw err;
+        }
+        cek = generateCek(encEntry);
+    }
+    let plaintext = await decrypt(encEntry, cek, token.ciphertext, token.iv, token.tag, token.additionalData);
+    if (joseHeader.zip === 'DEF') {
+        const maxDecompressedLength = options?.maxDecompressedLength ?? 250_000;
+        if (maxDecompressedLength === 0) {
+            throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
+        }
+        if (maxDecompressedLength !== Infinity &&
+            (!Number.isSafeInteger(maxDecompressedLength) || maxDecompressedLength < 1)) {
+            throw new TypeError('maxDecompressedLength must be 0, a positive safe integer, or Infinity');
+        }
+        plaintext = await decompress(plaintext, maxDecompressedLength).catch((cause) => {
+            if (cause instanceof JWEInvalid)
+                throw cause;
+            throw new JWEInvalid('Failed to decompress plaintext', { cause });
+        });
+    }
+    return { plaintext, parsedProt, key: k, resolvedKey };
+}
+export async function decryptJWE(jwe, shared, key) {
+    return decryptRecipient(jwe, shareJWE(jwe), shared, key);
+}
+export async function decryptCompact(jwe, shared, key) {
+    if (jwe instanceof Uint8Array) {
+        jwe = decoder.decode(jwe);
+    }
+    if (typeof jwe !== 'string') {
+        throw new JWEInvalid('Compact JWE must be a string or Uint8Array');
+    }
+    const { 0: protectedHeader, 1: encryptedKey, 2: iv, 3: ciphertext, 4: tag, length, } = jwe.split('.');
+    if (length !== 5) {
+        throw new JWEInvalid('Invalid Compact JWE');
+    }
+    return decryptJWE({
+        ciphertext,
+        iv: iv || undefined,
+        protected: protectedHeader,
+        tag: tag || undefined,
+        encrypted_key: encryptedKey || undefined,
+    }, shared, key);
+}