deadbyte-mcp 0.8.7

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

@@ -0,0 +1,18 @@
+import { createCompactSignature } from '../lib/jws_sign.js';
+import { JWTInvalid } from '../util/errors.js';
+import { JWTClaimsBuilder, jwtData } from '../lib/jwt_claims_set.js';
+import { assertNotSet } from '../lib/helpers.js';
+const SignJWT_base = JWTClaimsBuilder;
+export class SignJWT extends SignJWT_base {
+    #protectedHeader;
+    setProtectedHeader(protectedHeader) {
+        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
+        this.#protectedHeader = protectedHeader;
+        return this;
+    }
+    async sign(key, options) {
+        return createCompactSignature(jwtData(this), this.#protectedHeader, options?.crit, key, () => {
+            throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
+        });
+    }
+}

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

@@ -0,0 +1,43 @@
+import * as b64u from '../util/base64url.js';
+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(jwtData(this));
+        return `${header}.${payload}.`;
+    }
+    static decode(jwt, options) {
+        if (typeof jwt !== 'string') {
+            throw new JWTInvalid('Unsecured JWT must be a string');
+        }
+        const { 0: encodedHeader, 1: encodedPayload, 2: signature, length } = jwt.split('.');
+        if (length !== 3 || signature !== '') {
+            throw new JWTInvalid('Invalid Unsecured JWT');
+        }
+        let header;
+        let b64;
+        try {
+            header = parseJoseHeader(encodedHeader, JWSInvalid, 'JWS Protected Header is invalid');
+            const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, undefined, header, header);
+            b64 = validateB64(header, extensions);
+        }
+        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/jwt/verify.js

@@ -0,0 +1,15 @@
+import { prepareVerify, verifyCompact } from '../lib/jws_verify.js';
+import { validateClaimsSet } from '../lib/jwt_claims_set.js';
+import { JWTInvalid } from '../util/errors.js';
+export async function jwtVerify(jwt, key, options) {
+    const verified = await verifyCompact(jwt, prepareVerify(options), key);
+    if (!verified[2]) {
+        throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
+    }
+    const payload = validateClaimsSet(verified[1], verified[0], options);
+    const result = { payload, protectedHeader: verified[1] };
+    if (typeof key === 'function') {
+        return { ...result, key: verified[3] };
+    }
+    return result;
+}

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

@@ -0,0 +1,44 @@
+import { toSPKI as exportPublic, toPKCS8 as exportPrivate } from '../lib/asn1.js';
+import { invalidKeyInput } from '../lib/invalid_key_input.js';
+import { encode as b64u } from '../util/base64url.js';
+import { isCryptoKey, isKeyObject } from '../lib/is_key_like.js';
+function omitUndefinedProperties(jwk) {
+    return Object.fromEntries(Object.entries(jwk).filter(([, value]) => value !== undefined));
+}
+async function keyToJWK(key) {
+    if (isKeyObject(key)) {
+        if (key.type === 'secret') {
+            key = key.export();
+        }
+        else {
+            return key.export({ format: 'jwk' });
+        }
+    }
+    if (key instanceof Uint8Array) {
+        return {
+            kty: 'oct',
+            k: b64u(key),
+        };
+    }
+    if (!isCryptoKey(key)) {
+        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'Uint8Array'));
+    }
+    if (!key.extractable) {
+        throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');
+    }
+    const { ext, key_ops, alg, use, ...jwk } = omitUndefinedProperties(await crypto.subtle.exportKey('jwk', key));
+    if (jwk.kty === 'AKP') {
+        ;
+        jwk.alg = alg;
+    }
+    return jwk;
+}
+export function exportSPKI(key) {
+    return exportPublic(key);
+}
+export function exportPKCS8(key) {
+    return exportPrivate(key);
+}
+export function exportJWK(key) {
+    return keyToJWK(key);
+}

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

@@ -0,0 +1,52 @@
+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' ||
+        !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);
+    }
+    let algorithm;
+    if (entry.resolve) {
+        const crv = options?.crv ?? 'P-256';
+        switch (crv) {
+            case 'P-256':
+            case 'P-384':
+            case 'P-521':
+                algorithm = { name: 'ECDH', namedCurve: crv };
+                break;
+            case 'X25519':
+                algorithm = { name: 'X25519' };
+                break;
+            default:
+                throw new JOSENotSupported('Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, and X25519');
+        }
+    }
+    else {
+        if (entry.crv !== undefined && options?.crv !== undefined && options.crv !== entry.crv) {
+            throw new JOSENotSupported(`Invalid or unsupported crv option provided, the only supported value for ${alg} is ${entry.crv}`);
+        }
+        algorithm =
+            entry.kty[0] === 'RSA'
+                ? {
+                    ...entry.subtle,
+                    publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
+                    modulusLength: getModulusLengthOption(options),
+                }
+                : entry.subtle;
+    }
+    return crypto.subtle.generateKey(algorithm, extractable ?? false, [
+        ...entry.usages[1],
+        ...entry.usages[0],
+    ]);
+}

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

@@ -0,0 +1,41 @@
+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;
+    switch (alg) {
+        case 'HS256':
+        case 'HS384':
+        case 'HS512':
+            length = +alg.slice(-3);
+            algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
+            keyUsages = ['sign', 'verify'];
+            break;
+        case 'A128CBC-HS256':
+        case 'A192CBC-HS384':
+        case 'A256CBC-HS512':
+            return crypto.getRandomValues(new Uint8Array(+alg.slice(-3) >> 3));
+        case 'A128KW':
+        case 'A192KW':
+        case 'A256KW':
+            length = +alg.slice(1, 4);
+            algorithm = { name: 'AES-KW', length };
+            keyUsages = ['wrapKey', 'unwrapKey'];
+            break;
+        case 'A128GCMKW':
+        case 'A192GCMKW':
+        case 'A256GCMKW':
+        case 'A128GCM':
+        case 'A192GCM':
+        case 'A256GCM':
+            length = +alg.slice(1, 4);
+            algorithm = { name: 'AES-GCM', length };
+            keyUsages = ['encrypt', 'decrypt'];
+            break;
+        default:
+            unsupportedAlg(algArgument);
+    }
+    return crypto.subtle.generateKey(algorithm, extractable ?? false, keyUsages);
+}

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

@@ -0,0 +1,61 @@
+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 { 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');
+    }
+    return fromSPKI(spki, alg, options);
+}
+export async function importX509(x509, alg, options) {
+    if (typeof x509 !== 'string' || x509.indexOf('-----BEGIN CERTIFICATE-----') !== 0) {
+        throw new TypeError('"x509" must be X.509 formatted string');
+    }
+    return fromX509(x509, alg, options);
+}
+export async function importPKCS8(pkcs8, alg, options) {
+    if (typeof pkcs8 !== 'string' || pkcs8.indexOf('-----BEGIN PRIVATE KEY-----') !== 0) {
+        throw new TypeError('"pkcs8" must be PKCS#8 formatted string');
+    }
+    return fromPKCS8(pkcs8, alg, options);
+}
+export async function importJWK(jwk, alg, options) {
+    if (!isObject(jwk)) {
+        throw new TypeError('JWK must be an object');
+    }
+    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 (normalized.kty) {
+        case 'oct':
+            if (typeof normalized.k !== 'string') {
+                throw new TypeError('missing "k" (Key Value) Parameter value');
+            }
+            return decodeBase64URL(normalized.k);
+        case 'AKP': {
+            if (typeof jwkAlg !== 'string' || !jwkAlg) {
+                throw new TypeError('missing "alg" (Algorithm) Parameter value');
+            }
+            if (alg !== jwkAlg) {
+                throw new TypeError('JWK alg and alg option value mismatch');
+            }
+            return jwkToKey(keyAlgorithm(alg), { ...normalized, ext });
+        }
+        case 'RSA':
+        case 'EC':
+        case 'OKP':
+            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

@@ -0,0 +1,179 @@
+import { invalidKeyInput } from './invalid_key_input.js';
+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}-----`;
+};
+const genericExport = async (keyType, keyFormat, key) => {
+    if (isKeyObject(key)) {
+        if (key.type !== keyType) {
+            throw new TypeError(`key is not a ${keyType} key`);
+        }
+        return key.export({ format: 'pem', type: keyFormat });
+    }
+    if (!isCryptoKey(key)) {
+        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject'));
+    }
+    if (!key.extractable) {
+        throw new TypeError('CryptoKey is not extractable');
+    }
+    if (key.type !== keyType) {
+        throw new TypeError(`key is not a ${keyType} key`);
+    }
+    return formatPEM(encodeBase64(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
+};
+export const toSPKI = (key) => genericExport('public', 'spki', key);
+export const toPKCS8 = (key) => genericExport('private', 'pkcs8', key);
+const bytesEqual = (a, b) => {
+    if (a.byteLength !== b.length)
+        return false;
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};
+const createASN1State = (data) => ({ data, pos: 0 });
+const readByte = (state) => {
+    const byte = state.data[state.pos++];
+    if (byte === undefined) {
+        throw new Error('Unexpected end of ASN.1 input');
+    }
+    return byte;
+};
+const parseLength = (state) => {
+    const first = readByte(state);
+    if (first & 0x80) {
+        const lengthOfLen = first & 0x7f;
+        let length = 0;
+        for (let i = 0; i < lengthOfLen; i++) {
+            length = (length << 8) | readByte(state);
+        }
+        return length;
+    }
+    return first;
+};
+const skipElement = (state, count = 1) => {
+    while (count-- > 0) {
+        state.pos++;
+        const length = parseLength(state);
+        state.pos += length;
+    }
+};
+const expectTag = (state, expectedTag, errorMessage) => {
+    if (readByte(state) !== expectedTag) {
+        throw new Error(errorMessage);
+    }
+};
+const getSubarray = (state, length) => {
+    if (length < 0 || state.pos + length > state.data.length) {
+        throw new Error('Unexpected end of ASN.1 input');
+    }
+    const result = state.data.subarray(state.pos, state.pos + length);
+    state.pos += length;
+    return result;
+};
+const parseAlgorithmOID = (state) => {
+    expectTag(state, 0x06, 'Expected algorithm OID');
+    const oidLen = parseLength(state);
+    return getSubarray(state, oidLen);
+};
+function parseKeyHeader(state, keyFormat) {
+    expectTag(state, 0x30, `Invalid ${keyFormat === 'spki' ? 'SPKI' : 'PKCS#8'} structure`);
+    parseLength(state);
+    if (keyFormat === 'pkcs8') {
+        expectTag(state, 0x02, 'Expected version field');
+        const length = parseLength(state);
+        state.pos += length;
+    }
+    expectTag(state, 0x30, 'Expected algorithm identifier');
+    parseLength(state);
+}
+const parseECAlgorithmIdentifier = (state) => {
+    const algOid = parseAlgorithmOID(state);
+    if (bytesEqual(algOid, [0x2b, 0x65, 0x6e])) {
+        return 'X25519';
+    }
+    if (!bytesEqual(algOid, [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01])) {
+        throw new Error('Unsupported key algorithm');
+    }
+    expectTag(state, 0x06, 'Expected curve OID');
+    const curveOidLen = parseLength(state);
+    const curveOid = getSubarray(state, curveOidLen);
+    if (bytesEqual(curveOid, [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07]))
+        return 'P-256';
+    if (bytesEqual(curveOid, [0x2b, 0x81, 0x04, 0x00, 0x22]))
+        return 'P-384';
+    if (bytesEqual(curveOid, [0x2b, 0x81, 0x04, 0x00, 0x23]))
+        return 'P-521';
+    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);
+    }
+    const isPublic = keyFormat === 'spki';
+    let algorithm;
+    if (entry.resolve) {
+        try {
+            const state = createASN1State(keyData);
+            parseKeyHeader(state, keyFormat);
+            algorithm = entry.resolve({ crv: parseECAlgorithmIdentifier(state) });
+        }
+        catch {
+            throw new JOSENotSupported('Invalid or unsupported key format');
+        }
+    }
+    else {
+        algorithm = entry.subtle;
+    }
+    return crypto.subtle.importKey(keyFormat, keyData, algorithm, extractable ?? isPublic, entry.usages[isPublic ? 0 : 1]);
+};
+const processPEMData = (pem, pattern) => {
+    return decodeBase64(pem.replace(pattern, ''));
+};
+export const fromPKCS8 = (pem, alg, options) => {
+    const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g);
+    return genericImport('pkcs8', keyData, alg, options);
+};
+export const fromSPKI = (pem, alg, options) => {
+    const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g);
+    return genericImport('spki', keyData, alg, options);
+};
+function spkiFromX509(buf) {
+    const state = createASN1State(buf);
+    expectTag(state, 0x30, 'Invalid certificate structure');
+    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) {
+        skipElement(state, 6);
+    }
+    else {
+        skipElement(state, 5);
+    }
+    const spkiStart = state.pos;
+    expectTag(state, 0x30, 'Invalid SPKI structure');
+    const spkiContentLen = parseLength(state);
+    return buf.subarray(spkiStart, spkiStart + spkiContentLen + (state.pos - spkiStart));
+}
+export const fromX509 = (pem, alg, options) => {
+    let spki;
+    try {
+        const certificate = processPEMData(pem, /(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g);
+        spki = spkiFromX509(certificate);
+    }
+    catch (cause) {
+        throw new TypeError('Failed to parse the X.509 certificate', { cause });
+    }
+    return genericImport('spki', spki, alg, options);
+};

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

@@ -0,0 +1,22 @@
+export function encodeBase64(input) {
+    if (Uint8Array.prototype.toBase64) {
+        return input.toBase64();
+    }
+    const CHUNK_SIZE = 0x8000;
+    const arr = [];
+    for (let i = 0; i < input.length; i += CHUNK_SIZE) {
+        arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
+    }
+    return btoa(arr.join(''));
+}
+export function decodeBase64(encoded) {
+    if (Uint8Array.fromBase64) {
+        return Uint8Array.fromBase64(encoded);
+    }
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}

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

@@ -0,0 +1,44 @@
+export const encoder = new TextEncoder();
+export const decoder = new TextDecoder();
+export const strictDecoder = new TextDecoder('utf-8', { fatal: true });
+const MAX_INT32 = 2 ** 32;
+export function concat(...buffers) {
+    const size = buffers.reduce((acc, { length }) => acc + length, 0);
+    const buf = new Uint8Array(size);
+    let i = 0;
+    for (const buffer of buffers) {
+        buf.set(buffer, i);
+        i += buffer.length;
+    }
+    return buf;
+}
+function writeUInt32BE(buf, value, offset) {
+    if (value < 0 || value >= MAX_INT32) {
+        throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
+    }
+    buf.set([value >>> 24, value >>> 16, value >>> 8, value & 0xff], offset);
+}
+export function uint64be(value) {
+    const high = Math.floor(value / MAX_INT32);
+    const low = value % MAX_INT32;
+    const buf = new Uint8Array(8);
+    writeUInt32BE(buf, high, 0);
+    writeUInt32BE(buf, low, 4);
+    return buf;
+}
+export function uint32be(value) {
+    const buf = new Uint8Array(4);
+    writeUInt32BE(buf, value);
+    return buf;
+}
+export function encode(string) {
+    const bytes = new Uint8Array(string.length);
+    for (let i = 0; i < string.length; i++) {
+        const code = string.charCodeAt(i);
+        if (code > 127) {
+            throw new TypeError('non-ASCII string encountered in encode()');
+        }
+        bytes[i] = code;
+    }
+    return bytes;
+}

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

@@ -0,0 +1,134 @@
+import { concat, uint64be } from './buffer_utils.js';
+import { checkCryptoKey } from './crypto_key.js';
+import { invalidKeyInput } from './invalid_key_input.js';
+import { JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
+import { isCryptoKey } from './is_key_like.js';
+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`);
+    }
+}
+export const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
+export function checkIvLength(enc, iv) {
+    if (iv.length << 3 !== enc.ivBits) {
+        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 = 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}`,
+        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 * 8));
+    const tag = await cbcHmacTag(macKey, macData, keySize);
+    return { ciphertext, tag, iv };
+}
+async function timingSafeEqual(a, b) {
+    const algorithm = { name: 'HMAC', hash: 'SHA-256' };
+    const key = (await crypto.subtle.generateKey(algorithm, false, ['sign', 'verify']));
+    const aHmac = await crypto.subtle.sign(algorithm, key, a);
+    return crypto.subtle.verify(algorithm, key, aHmac, 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 * 8));
+    const expectedTag = await cbcHmacTag(macKey, macData, keySize);
+    try {
+        if (await timingSafeEqual(tag, expectedTag)) {
+            return new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
+        }
+    }
+    catch {
+    }
+    throw new JWEDecryptionFailed();
+}
+async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
+    const encKey = cek instanceof Uint8Array
+        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, [
+            'encrypt',
+        ])
+        : (checkCryptoKey(cek, enc.subtle, 'encrypt'), 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) {
+    const encKey = cek instanceof Uint8Array
+        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, [
+            'decrypt',
+        ])
+        : (checkCryptoKey(cek, enc.subtle, 'decrypt'), 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();
+    }
+}
+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);
+    }
+    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)) {
+        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');
+    }
+    if (!enc.cbc && tag.length !== 16) {
+        throw new JWEInvalid('Invalid Authentication Tag length');
+    }
+    checkIvLength(enc, iv);
+    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);
+}