@psnext/slingcli 3.0.20260820-2 → 3.0.20260827-1

package/node_modules/jose/dist/webapi/jwt/unsecured.js

@@ -1,46 +1,15 @@
 import * as b64u from '../util/base64url.js';
-import { strictDecoder } from '../lib/buffer_utils.js';
-import { decodeBase64url } from '../lib/helpers.js';
-import { JWTInvalid } from '../util/errors.js';
-import { validateClaimsSet, JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
-export class UnsecuredJWT {
-    #jwt;
-    constructor(payload = {}) {
-        this.#jwt = new JWTClaimsBuilder(payload);
-    }
+import { decodeBase64url, parseJoseHeader } from '../lib/helpers.js';
+import { JWSInvalid, JWTInvalid } from '../util/errors.js';
+import { validateClaimsSet, JWTClaimsBuilder, jwtData } from '../lib/jwt_claims_set.js';
+import { JWS_RECOGNIZED, validateB64, validateCrit } from '../lib/options.js';
+const UnsecuredJWT_base = JWTClaimsBuilder;
+export class UnsecuredJWT extends UnsecuredJWT_base {
     encode() {
         const header = b64u.encode(JSON.stringify({ alg: 'none' }));
-        const payload = b64u.encode(this.#jwt.data());
+        const payload = b64u.encode(jwtData(this));
         return `${header}.${payload}.`;
     }
-    setIssuer(issuer) {
-        this.#jwt.iss = issuer;
-        return this;
-    }
-    setSubject(subject) {
-        this.#jwt.sub = subject;
-        return this;
-    }
-    setAudience(audience) {
-        this.#jwt.aud = audience;
-        return this;
-    }
-    setJti(jwtId) {
-        this.#jwt.jti = jwtId;
-        return this;
-    }
-    setNotBefore(input) {
-        this.#jwt.nbf = input;
-        return this;
-    }
-    setExpirationTime(input) {
-        this.#jwt.exp = input;
-        return this;
-    }
-    setIssuedAt(input) {
-        this.#jwt.iat = input;
-        return this;
-    }
     static decode(jwt, options) {
         if (typeof jwt !== 'string') {
             throw new JWTInvalid('Unsecured JWT must be a string');
@@ -50,14 +19,24 @@ export class UnsecuredJWT {
             throw new JWTInvalid('Invalid Unsecured JWT');
         }
         let header;
+        let b64;
         try {
-            header = JSON.parse(strictDecoder.decode(b64u.decode(encodedHeader)));
-            if (header.alg !== 'none')
-                throw new Error();
+            header = parseJoseHeader(encodedHeader, JWSInvalid, 'JWS Protected Header is invalid');
+            const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, undefined, header, header);
+            b64 = validateB64(header, extensions);
         }
-        catch {
+        catch (cause) {
+            if (!(cause instanceof JWSInvalid)) {
+                throw cause;
+            }
+            throw new JWTInvalid('Invalid Unsecured JWT', { cause });
+        }
+        if (header.alg !== 'none') {
             throw new JWTInvalid('Invalid Unsecured JWT');
         }
+        if (!b64) {
+            throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
+        }
         const payload = validateClaimsSet(header, decodeBase64url(encodedPayload, 'payload', JWTInvalid), options);
         return { payload, header };
     }

package/node_modules/jose/dist/webapi/key/generate_key_pair.js

@@ -1,13 +1,17 @@
 import { JOSENotSupported } from '../util/errors.js';
+import { validateExtractableOption } from '../lib/key_options.js';
 import { keyAlgorithm, unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
 function getModulusLengthOption(options) {
     const modulusLength = options?.modulusLength ?? 2048;
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
+    if (typeof modulusLength !== 'number' ||
+        !Number.isInteger(modulusLength) ||
+        modulusLength < 2048) {
         throw new JOSENotSupported('Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used');
     }
     return modulusLength;
 }
 export async function generateKeyPair(alg, options) {
+    const extractable = validateExtractableOption(options?.extractable);
     const entry = keyAlgorithm(alg, algArgument);
     if (entry.secret) {
         unsupportedAlg(algArgument);
@@ -41,7 +45,7 @@ export async function generateKeyPair(alg, options) {
                 }
                 : entry.subtle;
     }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, [
+    return crypto.subtle.generateKey(algorithm, extractable ?? false, [
         ...entry.usages[1],
         ...entry.usages[0],
     ]);

package/node_modules/jose/dist/webapi/key/generate_secret.js

@@ -1,5 +1,7 @@
 import { unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
+import { validateExtractableOption } from '../lib/key_options.js';
 export async function generateSecret(alg, options) {
+    const extractable = validateExtractableOption(options?.extractable);
     let length;
     let algorithm;
     let keyUsages;
@@ -7,19 +9,18 @@ export async function generateSecret(alg, options) {
         case 'HS256':
         case 'HS384':
         case 'HS512':
-            length = parseInt(alg.slice(-3), 10);
+            length = +alg.slice(-3);
             algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
             keyUsages = ['sign', 'verify'];
             break;
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
-            length = parseInt(alg.slice(-3), 10);
-            return crypto.getRandomValues(new Uint8Array(length >> 3));
+            return crypto.getRandomValues(new Uint8Array(+alg.slice(-3) >> 3));
         case 'A128KW':
         case 'A192KW':
         case 'A256KW':
-            length = parseInt(alg.slice(1, 4), 10);
+            length = +alg.slice(1, 4);
             algorithm = { name: 'AES-KW', length };
             keyUsages = ['wrapKey', 'unwrapKey'];
             break;
@@ -29,12 +30,12 @@ export async function generateSecret(alg, options) {
         case 'A128GCM':
         case 'A192GCM':
         case 'A256GCM':
-            length = parseInt(alg.slice(1, 4), 10);
+            length = +alg.slice(1, 4);
             algorithm = { name: 'AES-GCM', length };
             keyUsages = ['encrypt', 'decrypt'];
             break;
         default:
             unsupportedAlg(algArgument);
     }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, keyUsages);
+    return crypto.subtle.generateKey(algorithm, extractable ?? false, keyUsages);
 }

package/node_modules/jose/dist/webapi/key/import.js

@@ -4,6 +4,8 @@ import { jwkToKey } from '../lib/jwk_to_key.js';
 import { keyAlgorithm } from '../lib/key_algorithm.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { isObject } from '../lib/type_checks.js';
+import { validateExtractableOption } from '../lib/key_options.js';
+import { normalizeJwk } from '../lib/jwk_metadata.js';
 export 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');
@@ -26,31 +28,33 @@ export async function importJWK(jwk, alg, options) {
     if (!isObject(jwk)) {
         throw new TypeError('JWK must be an object');
     }
-    alg ??= jwk.alg;
-    const ext = options?.extractable ?? jwk.ext;
-    if (jwk.kty !== 'oct' && !alg) {
+    const normalized = normalizeJwk(jwk);
+    const extractable = validateExtractableOption(options?.extractable);
+    const { alg: jwkAlg } = normalized;
+    alg ??= jwkAlg;
+    const ext = extractable ?? normalized.ext;
+    if (normalized.kty !== 'oct' && !alg) {
         throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
     }
-    switch (jwk.kty) {
+    switch (normalized.kty) {
         case 'oct':
-            if (typeof jwk.k !== 'string' || !jwk.k) {
+            if (typeof normalized.k !== 'string') {
                 throw new TypeError('missing "k" (Key Value) Parameter value');
             }
-            return decodeBase64URL(jwk.k);
-        case 'RSA':
-            return jwkToKey(keyAlgorithm(alg), { ...jwk, alg, ext });
+            return decodeBase64URL(normalized.k);
         case 'AKP': {
-            if (typeof jwk.alg !== 'string' || !jwk.alg) {
+            if (typeof jwkAlg !== 'string' || !jwkAlg) {
                 throw new TypeError('missing "alg" (Algorithm) Parameter value');
             }
-            if (alg !== undefined && alg !== jwk.alg) {
+            if (alg !== jwkAlg) {
                 throw new TypeError('JWK alg and alg option value mismatch');
             }
-            return jwkToKey(keyAlgorithm(jwk.alg), { ...jwk, ext });
+            return jwkToKey(keyAlgorithm(alg), { ...normalized, ext });
         }
+        case 'RSA':
         case 'EC':
         case 'OKP':
-            return jwkToKey(keyAlgorithm(alg), { ...jwk, alg, ext });
+            return jwkToKey(keyAlgorithm(alg), { ...normalized, alg, ext });
         default:
             throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
     }

package/node_modules/jose/dist/webapi/lib/asn1.js

@@ -3,6 +3,7 @@ import { encodeBase64, decodeBase64 } from '../lib/base64.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { keyAlgorithm, unsupportedAlg, algArgument } from './key_algorithm.js';
 import { isCryptoKey, isKeyObject } from './is_key_like.js';
+import { validateExtractableOption } from './key_options.js';
 const formatPEM = (b64, descriptor) => {
     const newlined = (b64.match(/.{1,64}/g) || []).join('\n');
     return `-----BEGIN ${descriptor}-----\n${newlined}\n-----END ${descriptor}-----`;
@@ -112,6 +113,7 @@ const parseECAlgorithmIdentifier = (state) => {
     throw new Error('Unsupported named curve');
 };
 const genericImport = async (keyFormat, keyData, alg, options) => {
+    const extractable = validateExtractableOption(options?.extractable);
     const entry = keyAlgorithm(alg, algArgument);
     if (entry.secret) {
         unsupportedAlg(algArgument);
@@ -131,7 +133,7 @@ const genericImport = async (keyFormat, keyData, alg, options) => {
     else {
         algorithm = entry.subtle;
     }
-    return crypto.subtle.importKey(keyFormat, keyData, algorithm, options?.extractable ?? isPublic, entry.usages[isPublic ? 0 : 1]);
+    return crypto.subtle.importKey(keyFormat, keyData, algorithm, extractable ?? isPublic, entry.usages[isPublic ? 0 : 1]);
 };
 const processPEMData = (pem, pattern) => {
     return decodeBase64(pem.replace(pattern, ''));
@@ -147,7 +149,10 @@ export const fromSPKI = (pem, alg, options) => {
 function spkiFromX509(buf) {
     const state = createASN1State(buf);
     expectTag(state, 0x30, 'Invalid certificate structure');
-    parseLength(state);
+    const certificateLength = parseLength(state);
+    if (certificateLength < 0 || state.pos + certificateLength > state.data.length) {
+        throw new Error('Unexpected end of ASN.1 input');
+    }
     expectTag(state, 0x30, 'Invalid tbsCertificate structure');
     parseLength(state);
     if (buf[state.pos] === 0xa0) {

package/node_modules/jose/dist/webapi/lib/content_encryption.js

@@ -51,25 +51,14 @@ 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 * 8));
     const expectedTag = await cbcHmacTag(macKey, macData, keySize);
-    let macCheckPassed;
     try {
-        macCheckPassed = await timingSafeEqual(tag, expectedTag);
+        if (await timingSafeEqual(tag, expectedTag)) {
+            return new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
+        }
     }
     catch {
     }
-    if (!macCheckPassed) {
-        throw new JWEDecryptionFailed();
-    }
-    let plaintext;
-    try {
-        plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
-    }
-    catch {
-    }
-    if (!plaintext) {
-        throw new JWEDecryptionFailed();
-    }
-    return plaintext;
+    throw new JWEDecryptionFailed();
 }
 async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const encKey = cek instanceof Uint8Array
@@ -132,6 +121,9 @@ export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!tag) {
         throw new JWEInvalid('JWE Authentication Tag missing');
     }
+    if (!enc.cbc && tag.length !== 16) {
+        throw new JWEInvalid('Invalid Authentication Tag length');
+    }
     checkIvLength(enc, iv);
     if (cek instanceof Uint8Array) {
         checkCekLength(cek, enc.cekBits);

package/node_modules/jose/dist/webapi/lib/deflate.js

@@ -1,5 +1,13 @@
 import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { concat } from './buffer_utils.js';
+export function validateZip(joseHeader, protectedHeader) {
+    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
+        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+    }
+    if (joseHeader.zip !== undefined && !protectedHeader?.zip) {
+        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
+    }
+}
 function supported(name) {
     if (typeof globalThis[name] === 'undefined') {
         throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);

package/node_modules/jose/dist/webapi/lib/helpers.js

@@ -3,7 +3,7 @@ import { encode, strictDecoder } from './buffer_utils.js';
 import { isObject } from './type_checks.js';
 export const unprotected = Symbol();
 export function assertNotSet(value, name) {
-    if (value) {
+    if (value !== undefined) {
         throw new TypeError(`${name} can only be called once`);
     }
 }

package/node_modules/jose/dist/webapi/lib/jwe_decrypt.js

@@ -7,35 +7,75 @@ 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) {
-    const { ciphertext, protected: encodedProtected, unprotected } = jwe;
-    if (jwe.iv !== undefined && typeof jwe.iv !== 'string') {
+import { decompress, validateZip } from './deflate.js';
+export function snapshotSharedJWE(jwe) {
+    const { aad, ciphertext, iv, protected: encodedProtected, tag, unprotected } = jwe;
+    if (iv !== undefined && typeof iv !== 'string') {
         throw new JWEInvalid('JWE Initialization Vector incorrect type');
     }
     if (typeof ciphertext !== 'string') {
         throw new JWEInvalid('JWE Ciphertext missing or incorrect type');
     }
-    if (jwe.tag !== undefined && typeof jwe.tag !== 'string') {
+    if (tag !== undefined && typeof tag !== 'string') {
         throw new JWEInvalid('JWE Authentication Tag incorrect type');
     }
     if (encodedProtected !== undefined && typeof encodedProtected !== 'string') {
         throw new JWEInvalid('JWE Protected Header incorrect type');
     }
-    if (jwe.aad !== undefined && typeof jwe.aad !== 'string') {
+    if (aad !== undefined && (typeof aad !== 'string' || !aad)) {
         throw new JWEInvalid('JWE AAD incorrect type');
     }
     if (unprotected !== undefined && !isObject(unprotected)) {
         throw new JWEInvalid('JWE Shared Unprotected Header incorrect type');
     }
+    return {
+        aad,
+        ciphertext,
+        iv,
+        protected: encodedProtected,
+        tag,
+        unprotected: unprotected === undefined ? undefined : { ...unprotected },
+    };
+}
+export function snapshotRecipientJWE(recipient) {
+    let header;
+    let headerAlg;
+    try {
+        const { header: inputHeader } = recipient;
+        if (isObject(inputHeader)) {
+            headerAlg = inputHeader.alg;
+            const parameters = Object.keys(inputHeader);
+            if (!parameters.includes('alg'))
+                headerAlg = undefined;
+            header = Object.fromEntries(parameters.map((parameter) => [
+                parameter,
+                parameter === 'alg' ? headerAlg : inputHeader[parameter],
+            ]));
+        }
+        else {
+            header = inputHeader;
+        }
+    }
+    catch (error) {
+        return [undefined, headerAlg, error];
+    }
+    try {
+        const { encrypted_key: encryptedKey } = recipient;
+        return [{ encrypted_key: encryptedKey, header }, headerAlg];
+    }
+    catch (error) {
+        return [undefined, headerAlg, error];
+    }
 }
 export function checkRecipient(jwe) {
     const { encrypted_key: encryptedKey, header } = jwe;
     if (encryptedKey !== undefined && typeof encryptedKey !== 'string') {
         throw new JWEInvalid('JWE Encrypted Key incorrect type');
     }
-    if (header !== undefined && !isObject(header)) {
-        throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
+    if (header !== undefined) {
+        if (!isObject(header)) {
+            throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
+        }
     }
     if (jwe.protected === undefined && header === undefined && jwe.unprotected === undefined) {
         throw new JWEInvalid('JOSE Header missing');
@@ -44,7 +84,7 @@ export function checkRecipient(jwe) {
 export function shareJWE(jwe) {
     const { protected: encodedProtected, ciphertext, iv, tag, aad } = jwe;
     let parsedProt;
-    if (encodedProtected) {
+    if (encodedProtected !== undefined) {
         parsedProt = parseJoseHeader(encodedProtected, JWEInvalid, 'JWE Protected Header is invalid');
     }
     const protectedHeader = encodedProtected !== undefined ? encode(encodedProtected) : new Uint8Array();
@@ -84,13 +124,14 @@ export function prepareDecrypt(options) {
         options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms),
         options &&
             validateAlgorithms('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms),
-        options,
+        options?.crit,
+        options?.maxPBES2Count,
+        options?.maxDecompressedLength,
     ];
 }
 export async function decryptRecipient(jwe, token, shared, key) {
-    const [keyManagementAlgorithms, contentEncryptionAlgorithms, options] = shared;
-    const [parsedProt, ciphertext, iv, tag, additionalData] = token;
-    const { encrypted_key: encodedKey, header, unprotected } = jwe;
+    const [parsedProt] = token;
+    const { header, unprotected } = jwe;
     let joseHeader;
     if (header !== undefined || unprotected !== undefined) {
         if (!isDisjoint(parsedProt, header, unprotected)) {
@@ -101,13 +142,14 @@ export async function decryptRecipient(jwe, token, shared, key) {
     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.');
-    }
+    return decryptRecipientCore(jwe, token, shared, key, joseHeader);
+}
+async function decryptRecipientCore(jwe, token, shared, key, joseHeader) {
+    const [keyManagementAlgorithms, contentEncryptionAlgorithms, crit, maxPBES2Count, maxDecompressedLength,] = shared;
+    const [parsedProt, ciphertext, iv, tag, additionalData] = token;
+    const { encrypted_key: encodedKey } = jwe;
+    validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, parsedProt, joseHeader);
+    validateZip(joseHeader, parsedProt);
     const { alg, enc } = joseHeader;
     if (typeof alg !== 'string' || !alg) {
         throw new JWEInvalid('missing JWE Algorithm (alg) in JWE Header');
@@ -136,7 +178,12 @@ export async function decryptRecipient(jwe, token, shared, key) {
     const k = await prepareKey(alg === 'dir' ? encEntry : algEntry, key, 'decrypt');
     let cek;
     try {
-        cek = await decryptKeyManagement(alg, encEntry, k, encryptedKey, joseHeader, options);
+        cek = await decryptKeyManagement(alg, encEntry, k, encryptedKey, joseHeader, maxPBES2Count);
+        if (encodedKey !== undefined &&
+            cek instanceof Uint8Array &&
+            cek.byteLength << 3 !== encEntry.cekBits) {
+            cek = generateCek(encEntry);
+        }
     }
     catch (err) {
         if (err instanceof TypeError || err instanceof JWEInvalid || err instanceof JOSENotSupported) {
@@ -146,15 +193,15 @@ export async function decryptRecipient(jwe, token, shared, key) {
     }
     let plaintext = await decrypt(encEntry, cek, ciphertext, iv, tag, additionalData);
     if (joseHeader.zip === 'DEF') {
-        const maxDecompressedLength = options?.maxDecompressedLength ?? 250_000;
-        if (maxDecompressedLength === 0) {
+        const decompressionLimit = maxDecompressedLength ?? 250_000;
+        if (decompressionLimit === 0) {
             throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
         }
-        if (maxDecompressedLength !== Infinity &&
-            (!Number.isSafeInteger(maxDecompressedLength) || maxDecompressedLength < 1)) {
+        if (decompressionLimit !== Infinity &&
+            (!Number.isSafeInteger(decompressionLimit) || decompressionLimit < 1)) {
             throw new TypeError('maxDecompressedLength must be 0, a positive safe integer, or Infinity');
         }
-        plaintext = await decompress(plaintext, maxDecompressedLength).catch((cause) => {
+        plaintext = await decompress(plaintext, decompressionLimit).catch((cause) => {
             if (cause instanceof JWEInvalid)
                 throw cause;
             throw new JWEInvalid('Failed to decompress plaintext', { cause });
@@ -176,11 +223,21 @@ export async function decryptCompact(jwe, shared, key) {
     if (length !== 5) {
         throw new JWEInvalid('Invalid Compact JWE');
     }
-    return decryptJWE({
+    const flattened = {
         ciphertext,
         iv: iv || undefined,
         protected: protectedHeader,
         tag: tag || undefined,
         encrypted_key: encryptedKey || undefined,
-    }, shared, key);
+    };
+    const parsedProt = parseJoseHeader(protectedHeader, JWEInvalid, 'JWE Protected Header is invalid');
+    const protectedBytes = encode(protectedHeader);
+    const token = [
+        parsedProt,
+        decodeBase64url(ciphertext, 'ciphertext', JWEInvalid),
+        iv ? decodeBase64url(iv, 'iv', JWEInvalid) : undefined,
+        tag ? decodeBase64url(tag, 'tag', JWEInvalid) : undefined,
+        protectedBytes,
+    ];
+    return decryptRecipientCore(flattened, token, shared, key, parsedProt);
 }

package/node_modules/jose/dist/webapi/lib/jwe_encrypt.js

@@ -1,33 +1,54 @@
 import { encode as b64u } from '../util/base64url.js';
 import { encrypt } from './content_encryption.js';
 import { encryptKeyManagement } from './key_management.js';
-import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
-import { isDisjoint } from './type_checks.js';
+import { JWEInvalid } from '../util/errors.js';
+import { assertUint8Array, isDisjoint, isObject } from './type_checks.js';
 import { concat, encode } from './buffer_utils.js';
-import { validateCrit, JWE_RECOGNIZED } from './options.js';
+import { serializeJoseHeader, validateCrit, validateCritDuplicates, JWE_RECOGNIZED, } from './options.js';
 import { prepareKey } from './key.js';
 import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
-import { compress } from './deflate.js';
+import { compress, validateZip } from './deflate.js';
+import { unprotected } from './helpers.js';
 export function checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader) {
     if (!isDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader)) {
         throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
     }
 }
 export function checkEncryptHeaders(input) {
-    const [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, , , , , crit] = input;
+    let [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, aad, cek, iv, keyManagementParameters, crit,] = input;
+    if (aad !== undefined) {
+        assertUint8Array(aad, 'JWE Additional Authenticated Data');
+    }
+    if (cek !== undefined) {
+        assertUint8Array(cek, 'JWE Content Encryption Key');
+    }
+    if (iv !== undefined) {
+        assertUint8Array(iv, 'JWE Initialization Vector');
+    }
+    if (protectedHeader !== undefined) {
+        protectedHeader = serializeJoseHeader(JWEInvalid, protectedHeader)[0];
+        input[1] = protectedHeader;
+    }
+    if (unprotectedHeader !== undefined) {
+        unprotectedHeader = serializeJoseHeader(JWEInvalid, unprotectedHeader)[0];
+        input[2] = unprotectedHeader;
+    }
+    if (sharedUnprotectedHeader !== undefined) {
+        sharedUnprotectedHeader = serializeJoseHeader(JWEInvalid, sharedUnprotectedHeader)[0];
+        input[3] = sharedUnprotectedHeader;
+    }
+    if (keyManagementParameters !== undefined && !isObject(keyManagementParameters)) {
+        throw new TypeError('JWE Key Management Parameters must be an object');
+    }
     checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader);
     const joseHeader = {
         ...protectedHeader,
         ...unprotectedHeader,
         ...sharedUnprotectedHeader,
     };
+    validateCritDuplicates(JWEInvalid, protectedHeader);
     validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, protectedHeader, joseHeader);
-    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-    }
-    if (joseHeader.zip !== undefined && !protectedHeader?.zip) {
-        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-    }
+    validateZip(joseHeader, protectedHeader);
     const { alg, enc } = joseHeader;
     if (typeof alg !== 'string' || !alg) {
         throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
@@ -109,6 +130,13 @@ export async function encryptJWE(input, checked, key) {
     }
     return jwe;
 }
-export async function createJWE(input, key) {
+export async function createJWE(input, key, options) {
+    if (!input[1] && !input[2] && !input[3]) {
+        throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
+    }
+    if (options !== undefined) {
+        input[8] = options?.crit;
+        input[9] = options ? unprotected in options : false;
+    }
     return encryptJWE(input, checkEncryptHeaders(input), key);
 }

package/node_modules/jose/dist/webapi/lib/jwk_metadata.js

@@ -0,0 +1,20 @@
+export function snapshotJwk(jwk) {
+    return { __proto__: null, ...jwk };
+}
+export function normalizeJwk(jwk) {
+    const normalized = snapshotJwk(jwk);
+    if (normalized.ext !== undefined && typeof normalized.ext !== 'boolean') {
+        throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
+    }
+    if (normalized.key_ops !== undefined) {
+        const value = normalized.key_ops;
+        const keyOps = Array.isArray(value) ? [...value] : undefined;
+        if (!keyOps ||
+            keyOps.some((operation) => typeof operation !== 'string') ||
+            new Set(keyOps).size !== keyOps.length) {
+            throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');
+        }
+        normalized.key_ops = keyOps;
+    }
+    return normalized;
+}