/* eslint-disable */
(function (f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.aesDecrypter = f() } })(function () {
  var define, module, exports; return (function e(t, n, r) { function s(o, u) { if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); var f = new Error("Cannot find module '" + o + "'"); throw f.code = "MODULE_NOT_FOUND", f } var l = n[o] = { exports: {} }; t[o][0].call(l.exports, function (e) { var n = t[o][1][e]; return s(n ? n : e) }, l, l.exports, e, t, n, r) } return n[o].exports } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++)s(r[o]); return s })({
    1: [function (require, module, exports) {
      /**
     * @file aes.js
     *
     * This file contains an adaptation of the AES decryption algorithm
     * from the Standford Javascript Cryptography Library. That work is
     * covered by the following copyright and permissions notice:
     *
     * Copyright 2009-2010 Emily Stark, Mike Hamburg, Dan Boneh.
     * All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are
     * met:
     *
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     *
     * 2. Redistributions in binary form must reproduce the above
     *    copyright notice, this list of conditions and the following
     *    disclaimer in the documentation and/or other materials provided
     *    with the distribution.
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE
     * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     *
     * The views and conclusions contained in the software and documentation
     * are those of the authors and should not be interpreted as representing
     * official policies, either expressed or implied, of the authors.
     */
      /**
       * Expand the S-box tables.
       *
       * @private
       */
      'use strict';
      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
      function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
      var precompute = function precompute() {
        var tables = [[[], [], [], [], []], [[], [], [], [], []]];
        var encTable = tables[0];
        var decTable = tables[1];
        var sbox = encTable[4];
        var sboxInv = decTable[4];
        var i = undefined;
        var x = undefined;
        var xInv = undefined;
        var d = [];
        var th = [];
        var x2 = undefined;
        var x4 = undefined;
        var x8 = undefined;
        var s = undefined;
        var tEnc = undefined;
        var tDec = undefined;
        // Compute double and third tables
        for (i = 0; i < 256; i++) {
          th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
        }
        for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
          // Compute sbox
          s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
          s = s >> 8 ^ s & 255 ^ 99;
          sbox[x] = s;
          sboxInv[s] = x;
          // Compute MixColumns
          x8 = d[x4 = d[x2 = d[x]]];
          tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
          tEnc = d[s] * 0x101 ^ s * 0x1010100;
          for (i = 0; i < 4; i++) {
            encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
            decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8;
          }
        }
        // Compactify. Considerable speedup on Firefox.
        for (i = 0; i < 5; i++) {
          encTable[i] = encTable[i].slice(0);
          decTable[i] = decTable[i].slice(0);
        }
        return tables;
      };
      var aesTables = null;
      /**
       * Schedule out an AES key for both encryption and decryption. This
       * is a low-level class. Use a cipher mode to do bulk encryption.
       *
       * @class AES
       * @param key {Array} The key as an array of 4, 6 or 8 words.
       */
      var AES = (function () {
        function AES(key) {
          _classCallCheck(this, AES);
          /**
           * The expanded S-box and inverse S-box tables. These will be computed
           * on the client so that we don't have to send them down the wire.
           *
           * There are two tables, _tables[0] is for encryption and
           * _tables[1] is for decryption.
           *
           * The first 4 sub-tables are the expanded S-box with MixColumns. The
           * last (_tables[01][4]) is the S-box itself.
           *
           * @private
           */
          // if we have yet to precompute the S-box tables
          // do so now
          if (!aesTables) {
            aesTables = precompute();
          }
          // then make a copy of that object for use
          this._tables = [[aesTables[0][0].slice(), aesTables[0][1].slice(), aesTables[0][2].slice(), aesTables[0][3].slice(), aesTables[0][4].slice()], [aesTables[1][0].slice(), aesTables[1][1].slice(), aesTables[1][2].slice(), aesTables[1][3].slice(), aesTables[1][4].slice()]];
          var i = undefined;
          var j = undefined;
          var tmp = undefined;
          var encKey = undefined;
          var decKey = undefined;
          var sbox = this._tables[0][4];
          var decTable = this._tables[1];
          var keyLen = key.length;
          var rcon = 1;
          if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
            throw new Error('Invalid aes key size');
          }
          encKey = key.slice(0);
          decKey = [];
          this._key = [encKey, decKey];
          // schedule encryption keys
          for (i = keyLen; i < 4 * keyLen + 28; i++) {
            tmp = encKey[i - 1];
            // apply sbox
            if (i % keyLen === 0 || keyLen === 8 && i % keyLen === 4) {
              tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255];
              // shift rows and add rcon
              if (i % keyLen === 0) {
                tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24;
                rcon = rcon << 1 ^ (rcon >> 7) * 283;
              }
            }
            encKey[i] = encKey[i - keyLen] ^ tmp;
          }
          // schedule decryption keys
          for (j = 0; i; j++, i--) {
            tmp = encKey[j & 3 ? i : i - 4];
            if (i <= 4 || j < 4) {
              decKey[j] = tmp;
            } else {
              decKey[j] = decTable[0][sbox[tmp >>> 24]] ^ decTable[1][sbox[tmp >> 16 & 255]] ^ decTable[2][sbox[tmp >> 8 & 255]] ^ decTable[3][sbox[tmp & 255]];
            }
          }
        }
        /**
         * Decrypt 16 bytes, specified as four 32-bit words.
         *
         * @param {Number} encrypted0 the first word to decrypt
         * @param {Number} encrypted1 the second word to decrypt
         * @param {Number} encrypted2 the third word to decrypt
         * @param {Number} encrypted3 the fourth word to decrypt
         * @param {Int32Array} out the array to write the decrypted words
         * into
         * @param {Number} offset the offset into the output array to start
         * writing results
         * @return {Array} The plaintext.
         */
        _createClass(AES, [{
          key: 'decrypt',
          value: function decrypt(encrypted0, encrypted1, encrypted2, encrypted3, out, offset) {
            var key = this._key[1];
            // state variables a,b,c,d are loaded with pre-whitened data
            var a = encrypted0 ^ key[0];
            var b = encrypted3 ^ key[1];
            var c = encrypted2 ^ key[2];
            var d = encrypted1 ^ key[3];
            var a2 = undefined;
            var b2 = undefined;
            var c2 = undefined;
            // key.length === 2 ?
            var nInnerRounds = key.length / 4 - 2;
            var i = undefined;
            var kIndex = 4;
            var table = this._tables[1];
            // load up the tables
            var table0 = table[0];
            var table1 = table[1];
            var table2 = table[2];
            var table3 = table[3];
            var sbox = table[4];
            // Inner rounds. Cribbed from OpenSSL.
            for (i = 0; i < nInnerRounds; i++) {
              a2 = table0[a >>> 24] ^ table1[b >> 16 & 255] ^ table2[c >> 8 & 255] ^ table3[d & 255] ^ key[kIndex];
              b2 = table0[b >>> 24] ^ table1[c >> 16 & 255] ^ table2[d >> 8 & 255] ^ table3[a & 255] ^ key[kIndex + 1];
              c2 = table0[c >>> 24] ^ table1[d >> 16 & 255] ^ table2[a >> 8 & 255] ^ table3[b & 255] ^ key[kIndex + 2];
              d = table0[d >>> 24] ^ table1[a >> 16 & 255] ^ table2[b >> 8 & 255] ^ table3[c & 255] ^ key[kIndex + 3];
              kIndex += 4;
              a = a2; b = b2; c = c2;
            }
            // Last round.
            for (i = 0; i < 4; i++) {
              out[(3 & -i) + offset] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++];
              a2 = a; a = b; b = c; c = d; d = a2;
            }
          }
        }]);
        return AES;
      })();
      exports['default'] = AES;
      module.exports = exports['default'];
    }, {}], 2: [function (require, module, exports) {
      /**
       * @file async-stream.js
       */
      'use strict';
      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
      var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
      function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
      function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
      function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
      var _stream = require('./stream');
      var _stream2 = _interopRequireDefault(_stream);
      /**
       * A wrapper around the Stream class to use setTiemout
       * and run stream "jobs" Asynchronously
       *
       * @class AsyncStream
       * @extends Stream
       */
      var AsyncStream = (function (_Stream) {
        _inherits(AsyncStream, _Stream);
        function AsyncStream() {
          _classCallCheck(this, AsyncStream);
          _get(Object.getPrototypeOf(AsyncStream.prototype), 'constructor', this).call(this, _stream2['default']);
          this.jobs = [];
          this.delay = 1;
          this.timeout_ = null;
        }
        /**
         * process an async job
         *
         * @private
         */
        _createClass(AsyncStream, [{
          key: 'processJob_',
          value: function processJob_() {
            this.jobs.shift()();
            if (this.jobs.length) {
              this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
            } else {
              this.timeout_ = null;
            }
          }
          /**
           * push a job into the stream
           *
           * @param {Function} job the job to push into the stream
           */
        }, {
          key: 'push',
          value: function push(job) {
            this.jobs.push(job);
            if (!this.timeout_) {
              this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
            }
          }
        }]);
        return AsyncStream;
      })(_stream2['default']);
      exports['default'] = AsyncStream;
      module.exports = exports['default'];
    }, { "./stream": 4 }], 3: [function (require, module, exports) {
      /**
       * @file decrypter.js
       *
       * An asynchronous implementation of AES-128 CBC decryption with
       * PKCS#7 padding.
       */
      'use strict';
      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
      function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
      function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
      var _globalWindow = require('global/window');
      var _globalWindow2 = _interopRequireDefault(_globalWindow);
      var _aes = require('./aes');
      var _aes2 = _interopRequireDefault(_aes);
      var _asyncStream = require('./async-stream');
      var _asyncStream2 = _interopRequireDefault(_asyncStream);
      var _pkcs7 = require('pkcs7');
      /**
       * Convert network-order (big-endian) bytes into their little-endian
       * representation.
       */
      var ntoh = function ntoh(word) {
        return word << 24 | (word & 0xff00) << 8 | (word & 0xff0000) >> 8 | word >>> 24;
      };
      /**
       * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
       *
       * @param {Uint32Array}  encrypted the encrypted bytes
       * @param {Uint32Array} key the bytes of the decryption key
       * @param {Uint32Array} initVector the initialization vector (IV) to
       * use for the first round of CBC.
       * @return {Uint8Array} the decrypted bytes
       *
       * @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
       * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
       * @see https://tools.ietf.org/html/rfc2315
       */
      var decryptNonNative = function decryptNonNative(encrypted, key, initVector) {
        // word-level access to the encrypted bytes
        var encrypted32 = new Int32Array(encrypted.buffer, encrypted.byteOffset, encrypted.byteLength >> 2);
        var decipher = new _aes2['default'](Array.prototype.slice.call(key));
        // byte and word-level access for the decrypted output
        var decrypted = new Uint8Array(encrypted.byteLength);
        var decrypted32 = new Int32Array(decrypted.buffer);
        // temporary variables for working with the IV, encrypted, and
        // decrypted data
        var init0 = undefined;
        var init1 = undefined;
        var init2 = undefined;
        var init3 = undefined;
        var encrypted0 = undefined;
        var encrypted1 = undefined;
        var encrypted2 = undefined;
        var encrypted3 = undefined;
        // iteration variable
        var wordIx = undefined;
        // pull out the words of the IV to ensure we don't modify the
        // passed-in reference and easier access
        init0 = initVector[0];
        init1 = initVector[1];
        init2 = initVector[2];
        init3 = initVector[3];
        // decrypt four word sequences, applying cipher-block chaining (CBC)
        // to each decrypted block
        for (wordIx = 0; wordIx < encrypted32.length; wordIx += 4) {
          // convert big-endian (network order) words into little-endian
          // (javascript order)
          encrypted0 = ntoh(encrypted32[wordIx]);
          encrypted1 = ntoh(encrypted32[wordIx + 1]);
          encrypted2 = ntoh(encrypted32[wordIx + 2]);
          encrypted3 = ntoh(encrypted32[wordIx + 3]);
          // decrypt the block
          decipher.decrypt(encrypted0, encrypted1, encrypted2, encrypted3, decrypted32, wordIx);
          // XOR with the IV, and restore network byte-order to obtain the
          // plaintext
          decrypted32[wordIx] = ntoh(decrypted32[wordIx] ^ init0);
          decrypted32[wordIx + 1] = ntoh(decrypted32[wordIx + 1] ^ init1);
          decrypted32[wordIx + 2] = ntoh(decrypted32[wordIx + 2] ^ init2);
          decrypted32[wordIx + 3] = ntoh(decrypted32[wordIx + 3] ^ init3);
          // setup the IV for the next round
          init0 = encrypted0;
          init1 = encrypted1;
          init2 = encrypted2;
          init3 = encrypted3;
        }
        return decrypted;
      };
      /**
       * The `Decrypter` class that manages decryption of AES
       * data through `AsyncStream` objects and the `decrypt`
       * function
       *
       * @param {Uint8Array} encrypted the encrypted bytes
       * @param {Uint8Array} key the bytes of the decryption key
       * @param {Uint32Array} initVector the initialization vector (IV) to
       * @param {Function} done the function to run when done
       * @class Decrypter
       */
      var Decrypter = (function () {
        function Decrypter(encrypted, key, initVector, done) {
          _classCallCheck(this, Decrypter);
          var view = new DataView(key.buffer);
          var littleEndianKey = new Uint32Array([view.getUint32(0), view.getUint32(4), view.getUint32(8), view.getUint32(12)]);
          var step = Decrypter.STEP;
          var encrypted32 = new Int32Array(encrypted.buffer);
          var decrypted = new Uint8Array(encrypted.byteLength);
          var i = 0;
          this.asyncStream_ = new _asyncStream2['default']();
          // split up the encryption job and do the individual chunks asynchronously
          this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), littleEndianKey, initVector, decrypted));
          for (i = step; i < encrypted32.length; i += step) {
            initVector = new Uint32Array([ntoh(encrypted32[i - 4]), ntoh(encrypted32[i - 3]), ntoh(encrypted32[i - 2]), ntoh(encrypted32[i - 1])]);
            this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), littleEndianKey, initVector, decrypted));
          }
          // invoke the done() callback when everything is finished
          this.asyncStream_.push(function () {
            // remove pkcs#7 padding from the decrypted bytes
            done(null, (0, _pkcs7.unpad)(decrypted));
          });
        }
        /**
         * Get a consistent crypto.subtle across various browsers.
         *
         * @return {WebCrypto Object}
         */
        /**
         * a getter for step the maximum number of bytes to process at one time
         *
         * @return {Number} the value of step 32000
         */
        _createClass(Decrypter, [{
          key: 'decryptChunk_',
          /**
           * @private
           */
          value: function decryptChunk_(encrypted, key, initVector, decrypted) {
            return function () {
              // decryptNonNative must be a separate function (not a method or
              // static method on Decrypter) else IE10 will crash.
              var bytes = decryptNonNative(encrypted, key, initVector);
              decrypted.set(bytes, encrypted.byteOffset);
            };
          }
        }], [{
          key: 'STEP',
          get: function get() {
            // 4 * 8000;
            return 32000;
          }
        }]);
        return Decrypter;
      })();
      exports.Decrypter = Decrypter;
      var getWebCrypto = function getWebCrypto() {
        // IE11 uses this prefix, but with an out of date version of the
        // spec that doesn't use Promises, and doesn't have native Promises
        // either, thus we fall back to the non-native decryption. Edge is
        // up to spec.
        if (_globalWindow2['default'].msCrypto) {
          return null;
        }
        var _crypto = _globalWindow2['default'].crypto;
        if (!_crypto) {
          return null;
        }
        // We shouldn't need to worry about Safari (which does HLSe
        // natively) but we use this for completeness.
        if (_crypto.webkitSubtle) {
          _crypto.subtle = _crypto.webkitSubtle;
        }
        return _crypto.subtle ? _crypto : null;
      };
      /**
       * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
       *
       * @param {Uint8Array} encrypted the encrypted bytes
       * @param {Uint8Array} key the bytes of the decryption key
       * @param {Uint32Array} iv the initialization vector (IV) to
       * use for the first round of CBC.
       * @param {Function} done callback that takes a Uint8Array
       *
       * @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
       * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
       * @see https://tools.ietf.org/html/rfc2315
       */
      var decryptWithWebCrypto = function decryptWithWebCrypto(encrypted, key, iv, done) {
        var crypto = getWebCrypto();
        var algorithm = { name: 'AES-CBC', iv: iv };
        var extractable = true;
        var usages = ['decrypt'];
        var keyPromise = crypto.subtle.importKey('raw', key, algorithm, extractable, usages);
        return keyPromise.then(function (importedKey) {
          return crypto.subtle.decrypt(algorithm, importedKey, encrypted);
        })['catch'](function (rejection) {
          return done(null, new Uint8Array());
        }).then(function (plaintextArrayBuffer) {
          return done(null, new Uint8Array(plaintextArrayBuffer));
        });
      };
      /**
       * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
       *
       * @param {Uint8Array} encrypted the encrypted bytes
       * @param {Uint8Array} key the bytes of the decryption key
       * @param {Uint32Array} iv the initialization vector (IV) to
       * use for the first round of CBC.
       * @return {Promise} that resolves with a Uint8Array the decrypted bytes
       *
       * @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
       * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
       * @see https://tools.ietf.org/html/rfc2315
       */
      var decryptWithDecrypter = function decryptWithDecrypter(encrypted, key, iv, done) {
        return new Decrypter(encrypted, key, iv, done);
      };
      /**
       * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
       * Chooses webcrypto or JS implementation where available.
       *
       * @param {Uint8Array} encrypted: the encrypted bytes
       * @param {Uint8Array} key: the bytes of the decryption key
       * @param {Uint32Array} iv: the initialization vector (IV) to
       * use for the first round of CBC.
       *
       * @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
       * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
       * @see https://tools.ietf.org/html/rfc2315
       */
      var decrypt = function decrypt(encrypted, key, iv, done) {
        var decryptionMethod = getWebCrypto() ? decryptWithWebCrypto : decryptWithDecrypter;
        return decryptionMethod(encrypted, key, iv, done);
      };
      exports.decrypt = decrypt;
      exports['default'] = decrypt;
    }, { "./aes": 1, "./async-stream": 2, "global/window": 5, "pkcs7": 7 }], 4: [function (require, module, exports) {
      /**
       * @file stream.js
       */
      /**
       * A lightweight readable stream implemention that handles event dispatching.
       *
       * @class Stream
       */
      'use strict';
      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
      function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
      var Stream = (function () {
        function Stream() {
          _classCallCheck(this, Stream);
          this.listeners = {};
        }
        /**
         * Add a listener for a specified event type.
         *
         * @param {String} type the event name
         * @param {Function} listener the callback to be invoked when an event of
         * the specified type occurs
         */
        _createClass(Stream, [{
          key: 'on',
          value: function on(type, listener) {
            if (!this.listeners[type]) {
              this.listeners[type] = [];
            }
            this.listeners[type].push(listener);
          }
          /**
           * Remove a listener for a specified event type.
           *
           * @param {String} type the event name
           * @param {Function} listener  a function previously registered for this
           * type of event through `on`
           * @return {Boolean} if we could turn it off or not
           */
        }, {
          key: 'off',
          value: function off(type, listener) {
            var index = undefined;
            if (!this.listeners[type]) {
              return false;
            }
            index = this.listeners[type].indexOf(listener);
            this.listeners[type].splice(index, 1);
            return index > -1;
          }
          /**
           * Trigger an event of the specified type on this stream. Any additional
           * arguments to this function are passed as parameters to event listeners.
           *
           * @param {String} type the event name
           */
        }, {
          key: 'trigger',
          value: function trigger(type) {
            var callbacks = undefined;
            var i = undefined;
            var length = undefined;
            var args = undefined;
            callbacks = this.listeners[type];
            if (!callbacks) {
              return;
            }
            // Slicing the arguments on every invocation of this method
            // can add a significant amount of overhead. Avoid the
            // intermediate object creation for the common case of a
            // single callback argument
            if (arguments.length === 2) {
              length = callbacks.length;
              for (i = 0; i < length; ++i) {
                callbacks[i].call(this, arguments[1]);
              }
            } else {
              args = Array.prototype.slice.call(arguments, 1);
              length = callbacks.length;
              for (i = 0; i < length; ++i) {
                callbacks[i].apply(this, args);
              }
            }
          }
          /**
           * Destroys the stream and cleans up.
           */
        }, {
          key: 'dispose',
          value: function dispose() {
            this.listeners = {};
          }
          /**
           * Forwards all `data` events on this stream to the destination stream. The
           * destination stream should provide a method `push` to receive the data
           * events as they arrive.
           *
           * @param {Stream} destination the stream that will receive all `data` events
           * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
           */
        }, {
          key: 'pipe',
          value: function pipe(destination) {
            this.on('data', function (data) {
              destination.push(data);
            });
          }
        }]);
        return Stream;
      })();
      exports['default'] = Stream;
      module.exports = exports['default'];
    }, {}], 5: [function (require, module, exports) {
      (function (global) {
        if (typeof window !== "undefined") {
          module.exports = window;
        } else if (typeof global !== "undefined") {
          module.exports = global;
        } else if (typeof self !== "undefined") {
          module.exports = self;
        } else {
          module.exports = {};
        }
      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}], 6: [function (require, module, exports) {
      /*
       * pkcs7.pad
       * https://github.com/brightcove/pkcs7
       *
       * Copyright (c) 2014 Brightcove
       * Licensed under the apache2 license.
       */
      'use strict';
      var PADDING;
      /**
       * Returns a new Uint8Array that is padded with PKCS#7 padding.
       * @param plaintext {Uint8Array} the input bytes before encryption
       * @return {Uint8Array} the padded bytes
       * @see http://tools.ietf.org/html/rfc5652
       */
      module.exports = function pad(plaintext) {
        var padding = PADDING[(plaintext.byteLength % 16) || 0],
          result = new Uint8Array(plaintext.byteLength + padding.length);
        result.set(plaintext);
        result.set(padding, plaintext.byteLength);
        return result;
      };
      // pre-define the padding values
      PADDING = [
        [16, 16, 16, 16,
          16, 16, 16, 16,
          16, 16, 16, 16,
          16, 16, 16, 16],
        [15, 15, 15, 15,
          15, 15, 15, 15,
          15, 15, 15, 15,
          15, 15, 15],
        [14, 14, 14, 14,
          14, 14, 14, 14,
          14, 14, 14, 14,
          14, 14],
        [13, 13, 13, 13,
          13, 13, 13, 13,
          13, 13, 13, 13,
          13],
        [12, 12, 12, 12,
          12, 12, 12, 12,
          12, 12, 12, 12],
        [11, 11, 11, 11,
          11, 11, 11, 11,
          11, 11, 11],
        [10, 10, 10, 10,
          10, 10, 10, 10,
          10, 10],
        [9, 9, 9, 9,
          9, 9, 9, 9,
          9],
        [8, 8, 8, 8,
          8, 8, 8, 8],
        [7, 7, 7, 7,
          7, 7, 7],
        [6, 6, 6, 6,
          6, 6],
        [5, 5, 5, 5,
          5],
        [4, 4, 4, 4],
        [3, 3, 3],
        [2, 2],
        [1]
      ];
    }, {}], 7: [function (require, module, exports) {
      /*
       * pkcs7
       * https://github.com/brightcove/pkcs7
       *
       * Copyright (c) 2014 Brightcove
       * Licensed under the apache2 license.
       */
      'use strict';
      exports.pad = require('./pad.js');
      exports.unpad = require('./unpad.js');
    }, { "./pad.js": 6, "./unpad.js": 8 }], 8: [function (require, module, exports) {
      /*
       * pkcs7.unpad
       * https://github.com/brightcove/pkcs7
       *
       * Copyright (c) 2014 Brightcove
       * Licensed under the apache2 license.
       */
      'use strict';
      /**
       * Returns the subarray of a Uint8Array without PKCS#7 padding.
       * @param padded {Uint8Array} unencrypted bytes that have been padded
       * @return {Uint8Array} the unpadded bytes
       * @see http://tools.ietf.org/html/rfc5652
       */
      module.exports = function unpad(padded) {
        return padded.subarray(0, padded.byteLength - padded[padded.byteLength - 1]);
      };
    }, {}], 9: [function (require, module, exports) {
      /**
       * @file index.js
       *
       * Index module to easily import the primary components of AES-128
       * decryption. Like this:
       *
       * ```js
       * import {Decrypter, decrypt, AsyncStream} from 'aes-decrypter';
       * ```
       */
      'use strict';
      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
      var _decrypter = require('./decrypter');
      var _asyncStream = require('./async-stream');
      var _asyncStream2 = _interopRequireDefault(_asyncStream);
      exports['default'] = {
        decrypt: _decrypter.decrypt,
        Decrypter: _decrypter.Decrypter,
        AsyncStream: _asyncStream2['default']
      };
      module.exports = exports['default'];
    }, { "./async-stream": 2, "./decrypter": 3 }]
  }, {}, [9])(9)
});
onmessage = (e) => {
  decrypt(e.data);
}
function decrypt(data) {
  function uint8ArrayToUint32Array(arrayBuffer) {
    const view = new DataView(arrayBuffer);
    const newArray = new Uint32Array(4);
    for (let i = 0; i < 4; i++) {
      newArray[i] = view.getUint32(i * 4);
    }
    return newArray;
  }
  const encrypted = new Uint8Array(
    data.encrypted
  );
  const iv = uint8ArrayToUint32Array(
    data.iv
  );
  const key = new Uint32Array(
    data.key
  );
  new aesDecrypter.Decrypter(
    encrypted,
    key,
    iv,
    function (err, bytes) {
      postMessage({
        decrypted: bytes.buffer,
        id: data.id
      }, [bytes.buffer]);
    }
  );
}
