conductor-oss 0.4.0 → 0.6.0

package/node_modules/jose/dist/webapi/jwe/flattened/decrypt.js

@@ -1,11 +1,12 @@
 import { decode as b64u } from '../../util/base64url.js';
-import { decrypt } from '../../lib/decrypt.js';
+import { decrypt } from '../../lib/content_encryption.js';
+import { decodeBase64url } from '../../lib/helpers.js';
 import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import { isDisjoint } from '../../lib/is_disjoint.js';
-import { isObject } from '../../lib/is_object.js';
-import { decryptKeyManagement } from '../../lib/decrypt_key_management.js';
+import { isDisjoint } from '../../lib/type_checks.js';
+import { isObject } from '../../lib/type_checks.js';
+import { decryptKeyManagement } from '../../lib/key_management.js';
 import { decoder, concat, encode } from '../../lib/buffer_utils.js';
-import { generateCek } from '../../lib/cek.js';
+import { generateCek } from '../../lib/content_encryption.js';
 import { validateCrit } from '../../lib/validate_crit.js';
 import { validateAlgorithms } from '../../lib/validate_algorithms.js';
 import { normalizeKey } from '../../lib/normalize_key.js';
@@ -86,12 +87,7 @@ export async function flattenedDecrypt(jwe, key, options) {
     }
     let encryptedKey;
     if (jwe.encrypted_key !== undefined) {
-        try {
-            encryptedKey = b64u(jwe.encrypted_key);
-        }
-        catch {
-            throw new JWEInvalid('Failed to base64url decode the encrypted_key');
-        }
+        encryptedKey = decodeBase64url(jwe.encrypted_key, 'encrypted_key', JWEInvalid);
     }
     let resolvedKey = false;
     if (typeof key === 'function') {
@@ -113,20 +109,10 @@ export async function flattenedDecrypt(jwe, key, options) {
     let iv;
     let tag;
     if (jwe.iv !== undefined) {
-        try {
-            iv = b64u(jwe.iv);
-        }
-        catch {
-            throw new JWEInvalid('Failed to base64url decode the iv');
-        }
+        iv = decodeBase64url(jwe.iv, 'iv', JWEInvalid);
     }
     if (jwe.tag !== undefined) {
-        try {
-            tag = b64u(jwe.tag);
-        }
-        catch {
-            throw new JWEInvalid('Failed to base64url decode the tag');
-        }
+        tag = decodeBase64url(jwe.tag, 'tag', JWEInvalid);
     }
     const protectedHeader = jwe.protected !== undefined ? encode(jwe.protected) : new Uint8Array();
     let additionalData;
@@ -136,13 +122,7 @@ export async function flattenedDecrypt(jwe, key, options) {
     else {
         additionalData = protectedHeader;
     }
-    let ciphertext;
-    try {
-        ciphertext = b64u(jwe.ciphertext);
-    }
-    catch {
-        throw new JWEInvalid('Failed to base64url decode the ciphertext');
-    }
+    const ciphertext = decodeBase64url(jwe.ciphertext, 'ciphertext', JWEInvalid);
     const plaintext = await decrypt(enc, cek, ciphertext, iv, tag, additionalData);
     const result = { plaintext };
     if (joseHeader.zip === 'DEF') {
@@ -160,12 +140,7 @@ export async function flattenedDecrypt(jwe, key, options) {
         result.protectedHeader = parsedProt;
     }
     if (jwe.aad !== undefined) {
-        try {
-            result.additionalAuthenticatedData = b64u(jwe.aad);
-        }
-        catch {
-            throw new JWEInvalid('Failed to base64url decode the aad');
-        }
+        result.additionalAuthenticatedData = decodeBase64url(jwe.aad, 'aad', JWEInvalid);
     }
     if (jwe.unprotected !== undefined) {
         result.sharedUnprotectedHeader = jwe.unprotected;

package/node_modules/jose/dist/webapi/jwe/flattened/encrypt.js

@@ -1,9 +1,9 @@
 import { encode as b64u } from '../../util/base64url.js';
-import { unprotected } from '../../lib/private_symbols.js';
-import { encrypt } from '../../lib/encrypt.js';
-import { encryptKeyManagement } from '../../lib/encrypt_key_management.js';
+import { unprotected, assertNotSet } from '../../lib/helpers.js';
+import { encrypt } from '../../lib/content_encryption.js';
+import { encryptKeyManagement } from '../../lib/key_management.js';
 import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import { isDisjoint } from '../../lib/is_disjoint.js';
+import { isDisjoint } from '../../lib/type_checks.js';
 import { concat, encode } from '../../lib/buffer_utils.js';
 import { validateCrit } from '../../lib/validate_crit.js';
 import { normalizeKey } from '../../lib/normalize_key.js';
@@ -25,30 +25,22 @@ export class FlattenedEncrypt {
         this.#plaintext = plaintext;
     }
     setKeyManagementParameters(parameters) {
-        if (this.#keyManagementParameters) {
-            throw new TypeError('setKeyManagementParameters can only be called once');
-        }
+        assertNotSet(this.#keyManagementParameters, 'setKeyManagementParameters');
         this.#keyManagementParameters = parameters;
         return this;
     }
     setProtectedHeader(protectedHeader) {
-        if (this.#protectedHeader) {
-            throw new TypeError('setProtectedHeader can only be called once');
-        }
+        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
         this.#protectedHeader = protectedHeader;
         return this;
     }
     setSharedUnprotectedHeader(sharedUnprotectedHeader) {
-        if (this.#sharedUnprotectedHeader) {
-            throw new TypeError('setSharedUnprotectedHeader can only be called once');
-        }
+        assertNotSet(this.#sharedUnprotectedHeader, 'setSharedUnprotectedHeader');
         this.#sharedUnprotectedHeader = sharedUnprotectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this.#unprotectedHeader) {
-            throw new TypeError('setUnprotectedHeader can only be called once');
-        }
+        assertNotSet(this.#unprotectedHeader, 'setUnprotectedHeader');
         this.#unprotectedHeader = unprotectedHeader;
         return this;
     }
@@ -57,16 +49,12 @@ export class FlattenedEncrypt {
         return this;
     }
     setContentEncryptionKey(cek) {
-        if (this.#cek) {
-            throw new TypeError('setContentEncryptionKey can only be called once');
-        }
+        assertNotSet(this.#cek, 'setContentEncryptionKey');
         this.#cek = cek;
         return this;
     }
     setInitializationVector(iv) {
-        if (this.#iv) {
-            throw new TypeError('setInitializationVector can only be called once');
-        }
+        assertNotSet(this.#iv, 'setInitializationVector');
         this.#iv = iv;
         return this;
     }

package/node_modules/jose/dist/webapi/jwe/general/decrypt.js

@@ -1,6 +1,6 @@
 import { flattenedDecrypt } from '../flattened/decrypt.js';
 import { JWEDecryptionFailed, JWEInvalid } from '../../util/errors.js';
-import { isObject } from '../../lib/is_object.js';
+import { isObject } from '../../lib/type_checks.js';
 export async function generalDecrypt(jwe, key, options) {
     if (!isObject(jwe)) {
         throw new JWEInvalid('General JWE must be an object');

package/node_modules/jose/dist/webapi/jwe/general/encrypt.js

@@ -1,9 +1,9 @@
 import { FlattenedEncrypt } from '../flattened/encrypt.js';
-import { unprotected } from '../../lib/private_symbols.js';
+import { unprotected, assertNotSet } from '../../lib/helpers.js';
 import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import { generateCek } from '../../lib/cek.js';
-import { isDisjoint } from '../../lib/is_disjoint.js';
-import { encryptKeyManagement } from '../../lib/encrypt_key_management.js';
+import { generateCek } from '../../lib/content_encryption.js';
+import { isDisjoint } from '../../lib/type_checks.js';
+import { encryptKeyManagement } from '../../lib/key_management.js';
 import { encode as b64u } from '../../util/base64url.js';
 import { validateCrit } from '../../lib/validate_crit.js';
 import { normalizeKey } from '../../lib/normalize_key.js';
@@ -20,16 +20,12 @@ class IndividualRecipient {
         this.options = options;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this.unprotectedHeader) {
-            throw new TypeError('setUnprotectedHeader can only be called once');
-        }
+        assertNotSet(this.unprotectedHeader, 'setUnprotectedHeader');
         this.unprotectedHeader = unprotectedHeader;
         return this;
     }
     setKeyManagementParameters(parameters) {
-        if (this.keyManagementParameters) {
-            throw new TypeError('setKeyManagementParameters can only be called once');
-        }
+        assertNotSet(this.keyManagementParameters, 'setKeyManagementParameters');
         this.keyManagementParameters = parameters;
         return this;
     }
@@ -58,16 +54,12 @@ export class GeneralEncrypt {
         return recipient;
     }
     setProtectedHeader(protectedHeader) {
-        if (this.#protectedHeader) {
-            throw new TypeError('setProtectedHeader can only be called once');
-        }
+        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
         this.#protectedHeader = protectedHeader;
         return this;
     }
     setSharedUnprotectedHeader(sharedUnprotectedHeader) {
-        if (this.#unprotectedHeader) {
-            throw new TypeError('setSharedUnprotectedHeader can only be called once');
-        }
+        assertNotSet(this.#unprotectedHeader, 'setSharedUnprotectedHeader');
         this.#unprotectedHeader = sharedUnprotectedHeader;
         return this;
     }

package/node_modules/jose/dist/webapi/jwk/embedded.js

@@ -1,5 +1,5 @@
 import { importJWK } from '../key/import.js';
-import { isObject } from '../lib/is_object.js';
+import { isObject } from '../lib/type_checks.js';
 import { JWSInvalid } from '../util/errors.js';
 export async function EmbeddedJWK(protectedHeader, token) {
     const joseHeader = {

package/node_modules/jose/dist/webapi/jwk/thumbprint.js

@@ -1,9 +1,9 @@
-import { digest } from '../lib/digest.js';
+import { digest } from '../lib/helpers.js';
 import { encode as b64u } from '../util/base64url.js';
 import { JOSENotSupported, JWKInvalid } from '../util/errors.js';
 import { encode } from '../lib/buffer_utils.js';
 import { isKeyLike } from '../lib/is_key_like.js';
-import { isJWK } from '../lib/is_jwk.js';
+import { isJWK } from '../lib/type_checks.js';
 import { exportJWK } from '../key/export.js';
 import { invalidKeyInput } from '../lib/invalid_key_input.js';
 const check = (value, description) => {

package/node_modules/jose/dist/webapi/jwks/local.js

@@ -1,6 +1,6 @@
 import { importJWK } from '../key/import.js';
 import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
-import { isObject } from '../lib/is_object.js';
+import { isObject } from '../lib/type_checks.js';
 function getKtyFromAlg(alg) {
     switch (typeof alg === 'string' && alg.slice(0, 2)) {
         case 'RS':

package/node_modules/jose/dist/webapi/jwks/remote.js

@@ -1,6 +1,6 @@
 import { JOSEError, JWKSNoMatchingKey, JWKSTimeout } from '../util/errors.js';
 import { createLocalJWKSet } from './local.js';
-import { isObject } from '../lib/is_object.js';
+import { isObject } from '../lib/type_checks.js';
 function isCloudflareWorkers() {
     return (typeof WebSocketPair !== 'undefined' ||
         (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers') ||
@@ -9,7 +9,7 @@ function isCloudflareWorkers() {
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'jose';
-    const VERSION = 'v6.2.0';
+    const VERSION = 'v6.2.1';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();

package/node_modules/jose/dist/webapi/jws/flattened/sign.js

@@ -1,11 +1,12 @@
 import { encode as b64u } from '../../util/base64url.js';
-import { sign } from '../../lib/sign.js';
-import { isDisjoint } from '../../lib/is_disjoint.js';
+import { sign } from '../../lib/signing.js';
+import { isDisjoint } from '../../lib/type_checks.js';
 import { JWSInvalid } from '../../util/errors.js';
 import { concat, encode } from '../../lib/buffer_utils.js';
 import { checkKeyType } from '../../lib/check_key_type.js';
 import { validateCrit } from '../../lib/validate_crit.js';
 import { normalizeKey } from '../../lib/normalize_key.js';
+import { assertNotSet } from '../../lib/helpers.js';
 export class FlattenedSign {
     #payload;
     #protectedHeader;
@@ -17,16 +18,12 @@ export class FlattenedSign {
         this.#payload = payload;
     }
     setProtectedHeader(protectedHeader) {
-        if (this.#protectedHeader) {
-            throw new TypeError('setProtectedHeader can only be called once');
-        }
+        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
         this.#protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this.#unprotectedHeader) {
-            throw new TypeError('setUnprotectedHeader can only be called once');
-        }
+        assertNotSet(this.#unprotectedHeader, 'setUnprotectedHeader');
         this.#unprotectedHeader = unprotectedHeader;
         return this;
     }

package/node_modules/jose/dist/webapi/jws/flattened/verify.js

@@ -1,9 +1,10 @@
 import { decode as b64u } from '../../util/base64url.js';
-import { verify } from '../../lib/verify.js';
+import { verify } from '../../lib/signing.js';
 import { JOSEAlgNotAllowed, JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
 import { concat, encoder, decoder, encode } from '../../lib/buffer_utils.js';
-import { isDisjoint } from '../../lib/is_disjoint.js';
-import { isObject } from '../../lib/is_object.js';
+import { decodeBase64url } from '../../lib/helpers.js';
+import { isDisjoint } from '../../lib/type_checks.js';
+import { isObject } from '../../lib/type_checks.js';
 import { checkKeyType } from '../../lib/check_key_type.js';
 import { validateCrit } from '../../lib/validate_crit.js';
 import { validateAlgorithms } from '../../lib/validate_algorithms.js';
@@ -79,13 +80,7 @@ export async function flattenedVerify(jws, key, options) {
             ? encode(jws.payload)
             : encoder.encode(jws.payload)
         : jws.payload);
-    let signature;
-    try {
-        signature = b64u(jws.signature);
-    }
-    catch {
-        throw new JWSInvalid('Failed to base64url decode the signature');
-    }
+    const signature = decodeBase64url(jws.signature, 'signature', JWSInvalid);
     const k = await normalizeKey(key, alg);
     const verified = await verify(alg, k, signature, data);
     if (!verified) {
@@ -93,12 +88,7 @@ export async function flattenedVerify(jws, key, options) {
     }
     let payload;
     if (b64) {
-        try {
-            payload = b64u(jws.payload);
-        }
-        catch {
-            throw new JWSInvalid('Failed to base64url decode the payload');
-        }
+        payload = decodeBase64url(jws.payload, 'payload', JWSInvalid);
     }
     else if (typeof jws.payload === 'string') {
         payload = encoder.encode(jws.payload);

package/node_modules/jose/dist/webapi/jws/general/sign.js

@@ -1,5 +1,6 @@
 import { FlattenedSign } from '../flattened/sign.js';
 import { JWSInvalid } from '../../util/errors.js';
+import { assertNotSet } from '../../lib/helpers.js';
 class IndividualSignature {
     #parent;
     protectedHeader;
@@ -12,16 +13,12 @@ class IndividualSignature {
         this.options = options;
     }
     setProtectedHeader(protectedHeader) {
-        if (this.protectedHeader) {
-            throw new TypeError('setProtectedHeader can only be called once');
-        }
+        assertNotSet(this.protectedHeader, 'setProtectedHeader');
         this.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this.unprotectedHeader) {
-            throw new TypeError('setUnprotectedHeader can only be called once');
-        }
+        assertNotSet(this.unprotectedHeader, 'setUnprotectedHeader');
         this.unprotectedHeader = unprotectedHeader;
         return this;
     }

package/node_modules/jose/dist/webapi/jws/general/verify.js

@@ -1,6 +1,6 @@
 import { flattenedVerify } from '../flattened/verify.js';
 import { JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
-import { isObject } from '../../lib/is_object.js';
+import { isObject } from '../../lib/type_checks.js';
 export async function generalVerify(jws, key, options) {
     if (!isObject(jws)) {
         throw new JWSInvalid('General JWS must be an object');

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

@@ -1,5 +1,6 @@
 import { CompactEncrypt } from '../jwe/compact/encrypt.js';
 import { JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
+import { assertNotSet } from '../lib/helpers.js';
 export class EncryptJWT {
     #cek;
     #iv;
@@ -41,30 +42,22 @@ export class EncryptJWT {
         return this;
     }
     setProtectedHeader(protectedHeader) {
-        if (this.#protectedHeader) {
-            throw new TypeError('setProtectedHeader can only be called once');
-        }
+        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
         this.#protectedHeader = protectedHeader;
         return this;
     }
     setKeyManagementParameters(parameters) {
-        if (this.#keyManagementParameters) {
-            throw new TypeError('setKeyManagementParameters can only be called once');
-        }
+        assertNotSet(this.#keyManagementParameters, 'setKeyManagementParameters');
         this.#keyManagementParameters = parameters;
         return this;
     }
     setContentEncryptionKey(cek) {
-        if (this.#cek) {
-            throw new TypeError('setContentEncryptionKey can only be called once');
-        }
+        assertNotSet(this.#cek, 'setContentEncryptionKey');
         this.#cek = cek;
         return this;
     }
     setInitializationVector(iv) {
-        if (this.#iv) {
-            throw new TypeError('setInitializationVector can only be called once');
-        }
+        assertNotSet(this.#iv, 'setInitializationVector');
         this.#iv = iv;
         return this;
     }

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

@@ -2,7 +2,7 @@ import { decode as decodeBase64URL } from '../util/base64url.js';
 import { fromSPKI, fromPKCS8, fromX509 } from '../lib/asn1.js';
 import { jwkToKey } from '../lib/jwk_to_key.js';
 import { JOSENotSupported } from '../util/errors.js';
-import { isObject } from '../lib/is_object.js';
+import { isObject } from '../lib/type_checks.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');

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

@@ -1,5 +1,4 @@
-import { encrypt } from './encrypt.js';
-import { decrypt } from './decrypt.js';
+import { encrypt, decrypt } from './content_encryption.js';
 import { encode as b64u } from '../util/base64url.js';
 export async function wrap(alg, key, cek, iv) {
     const jweAlgorithm = alg.slice(0, 7);

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

@@ -1,6 +1,6 @@
 import { withAlg as invalidKeyInput } from './invalid_key_input.js';
 import { isKeyLike } from './is_key_like.js';
-import * as jwk from './is_jwk.js';
+import * as jwk from './type_checks.js';
 const tag = (key) => key?.[Symbol.toStringTag];
 const jwkMatchesOp = (alg, key, usage) => {
     if (key.use !== undefined) {

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

@@ -0,0 +1,217 @@
+import { concat, uint64be } from './buffer_utils.js';
+import { checkEncCryptoKey } from './crypto_key.js';
+import { invalidKeyInput } from './invalid_key_input.js';
+import { JOSENotSupported, 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));
+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 function checkIvLength(enc, iv) {
+    if (iv.length << 3 !== ivBitLength(enc)) {
+        throw new JWEInvalid('Invalid Initialization Vector length');
+    }
+}
+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 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}`,
+        name: 'HMAC',
+    }, false, ['sign']);
+    return { encKey, macKey, keySize };
+}
+async function cbcHmacTag(macKey, macData, keySize) {
+    return new Uint8Array((await crypto.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3));
+}
+async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
+    const { encKey, macKey, keySize } = await cbcKeySetup(enc, cek, 'encrypt');
+    const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+        iv: iv,
+        name: 'AES-CBC',
+    }, encKey, plaintext));
+    const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
+    const tag = await cbcHmacTag(macKey, macData, keySize);
+    return { ciphertext, tag, iv };
+}
+async function timingSafeEqual(a, b) {
+    if (!(a instanceof Uint8Array)) {
+        throw new TypeError('First argument must be a buffer');
+    }
+    if (!(b instanceof Uint8Array)) {
+        throw new TypeError('Second argument must be a buffer');
+    }
+    const algorithm = { name: 'HMAC', hash: 'SHA-256' };
+    const key = (await crypto.subtle.generateKey(algorithm, false, ['sign']));
+    const aHmac = new Uint8Array(await crypto.subtle.sign(algorithm, key, a));
+    const bHmac = new Uint8Array(await crypto.subtle.sign(algorithm, key, b));
+    let out = 0;
+    let i = -1;
+    while (++i < 32) {
+        out |= aHmac[i] ^ bHmac[i];
+    }
+    return out === 0;
+}
+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 expectedTag = await cbcHmacTag(macKey, macData, keySize);
+    let macCheckPassed;
+    try {
+        macCheckPassed = await timingSafeEqual(tag, expectedTag);
+    }
+    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;
+}
+async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
+    let encKey;
+    if (cek instanceof Uint8Array) {
+        encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt']);
+    }
+    else {
+        checkEncCryptoKey(cek, enc, 'encrypt');
+        encKey = cek;
+    }
+    const encrypted = new Uint8Array(await crypto.subtle.encrypt({
+        additionalData: aad,
+        iv: iv,
+        name: 'AES-GCM',
+        tagLength: 128,
+    }, encKey, plaintext));
+    const tag = encrypted.slice(-16);
+    const ciphertext = encrypted.slice(0, -16);
+    return { ciphertext, tag, iv };
+}
+async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+    let encKey;
+    if (cek instanceof Uint8Array) {
+        encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt']);
+    }
+    else {
+        checkEncCryptoKey(cek, enc, 'decrypt');
+        encKey = cek;
+    }
+    try {
+        return new Uint8Array(await crypto.subtle.decrypt({
+            additionalData: aad,
+            iv: iv,
+            name: 'AES-GCM',
+            tagLength: 128,
+        }, encKey, concat(ciphertext, tag)));
+    }
+    catch {
+        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'));
+    }
+    if (iv) {
+        checkIvLength(enc, iv);
+    }
+    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);
+    }
+}
+export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
+    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
+        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
+    }
+    if (!iv) {
+        throw new JWEInvalid('JWE Initialization Vector missing');
+    }
+    if (!tag) {
+        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);
+    }
+}