text: import { decode as base64url } from '../../runtime/base64url.js';
  import decrypt from '../../runtime/decrypt.js';
  import { inflate } from '../../runtime/zlib.js';
  import random from '../../runtime/random.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 { encoder, decoder, concat } from '../../lib/buffer_utils.js';
  import cekFactory from '../../lib/cek.js';
  import validateCrit from '../../lib/validate_crit.js';
  import validateAlgorithms from '../../lib/validate_algorithms.js';
  const generateCek = cekFactory(random);
  const checkExtensions = validateCrit.bind(undefined, JWEInvalid, new Map());
  const checkAlgOption = validateAlgorithms.bind(undefined, 'keyManagementAlgorithms');
  const checkEncOption = validateAlgorithms.bind(undefined, 'contentEncryptionAlgorithms');
  async function flattenedDecrypt(jwe, key, options) {
      var _a;
      if (!isObject(jwe)) {
          throw new JWEInvalid('Flattened JWE must be an object');
      }
      if (jwe.protected === undefined && jwe.header === undefined && jwe.unprotected === undefined) {
          throw new JWEInvalid('JOSE Header missing');
      }
      if (typeof jwe.iv !== 'string') {
          throw new JWEInvalid('JWE Initialization Vector missing or incorrect type');
      }
      if (typeof jwe.ciphertext !== 'string') {
          throw new JWEInvalid('JWE Ciphertext missing or incorrect type');
      }
      if (typeof jwe.tag !== 'string') {
          throw new JWEInvalid('JWE Authentication Tag missing or incorrect type');
      }
      if (jwe.protected !== undefined && typeof jwe.protected !== 'string') {
          throw new JWEInvalid('JWE Protected Header incorrect type');
      }
      if (jwe.encrypted_key !== undefined && typeof jwe.encrypted_key !== 'string') {
          throw new JWEInvalid('JWE Encrypted Key incorrect type');
      }
      if (jwe.aad !== undefined && typeof jwe.aad !== 'string') {
          throw new JWEInvalid('JWE AAD incorrect type');
      }
      if (jwe.header !== undefined && !isObject(jwe.header)) {
          throw new JWEInvalid('JWE Shared Unprotected Header incorrect type');
      }
      if (jwe.unprotected !== undefined && !isObject(jwe.unprotected)) {
          throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
      }
      let parsedProt;
      if (jwe.protected) {
          const protectedHeader = base64url(jwe.protected);
          try {
              parsedProt = JSON.parse(decoder.decode(protectedHeader));
          }
          catch {
              throw new JWEInvalid('JWE Protected Header is invalid');
          }
      }
      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');
      }
      const joseHeader = {
          ...parsedProt,
          ...jwe.header,
          ...jwe.unprotected,
      };
      checkExtensions(options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader);
      if (joseHeader.zip !== undefined) {
          if (!parsedProt || !parsedProt.zip) {
              throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
          }
          if (joseHeader.zip !== 'DEF') {
              throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value');
          }
      }
      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 = options && checkAlgOption(options.keyManagementAlgorithms);
      const contentEncryptionAlgorithms = options && checkEncOption(options.contentEncryptionAlgorithms);
      if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg)) {
          throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed');
      }
      if (contentEncryptionAlgorithms && !contentEncryptionAlgorithms.has(enc)) {
          throw new JOSEAlgNotAllowed('"enc" (Encryption Algorithm) Header Parameter not allowed');
      }
      let encryptedKey;
      if (jwe.encrypted_key !== undefined) {
          encryptedKey = base64url(jwe.encrypted_key);
      }
      let resolvedKey = false;
      if (typeof key === 'function') {
          key = await key(parsedProt, jwe);
          resolvedKey = true;
      }
      let cek;
      try {
          cek = await decryptKeyManagement(alg, key, encryptedKey, joseHeader);
      }
      catch (err) {
          if (err instanceof TypeError) {
              throw err;
          }
          cek = generateCek(enc);
      }
      const iv = base64url(jwe.iv);
      const tag = base64url(jwe.tag);
      const protectedHeader = encoder.encode((_a = jwe.protected) !== null && _a !== void 0 ? _a : '');
      let additionalData;
      if (jwe.aad !== undefined) {
          additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(jwe.aad));
      }
      else {
          additionalData = protectedHeader;
      }
      let plaintext = await decrypt(enc, cek, base64url(jwe.ciphertext), iv, tag, additionalData);
      if (joseHeader.zip === 'DEF') {
          plaintext = await ((options === null || options === void 0 ? void 0 : options.inflateRaw) || inflate)(plaintext);
      }
      const result = { plaintext };
      if (jwe.protected !== undefined) {
          result.protectedHeader = parsedProt;
      }
      if (jwe.aad !== undefined) {
          result.additionalAuthenticatedData = base64url(jwe.aad);
      }
      if (jwe.unprotected !== undefined) {
          result.sharedUnprotectedHeader = jwe.unprotected;
      }
      if (jwe.header !== undefined) {
          result.unprotectedHeader = jwe.header;
      }
      if (resolvedKey) {
          return { ...result, key };
      }
      return result;
  }
  export { flattenedDecrypt };
  export default flattenedDecrypt;
  