Implement the AESBaseCipher class and let the AES128Cipher and AES256Cipher classes extend it

src/core/crypto.js

@@ -15,7 +15,7 @@
 
 import {
   bytesToString, FormatError, PasswordException, PasswordResponses,
-  stringToBytes, utf8StringToString, warn
+  stringToBytes, unreachable, utf8StringToString, warn
 } from '../shared/util';
 import { isDict, isName, Name } from './primitives';
 import { DecryptStream } from './stream';
@@ -629,35 +629,13 @@ var NullCipher = (function NullCipherClosure() {
   return NullCipher;
 })();
 
-var AES128Cipher = (function AES128CipherClosure() {
+class AESBaseCipher {
-  const CYCLES_OF_REPETITION = 10;
+  constructor() {
-  const KEY_SIZE = 160; // bits
+    if (this.constructor === AESBaseCipher) {
+      unreachable('Cannot initialize AESBaseCipher.');
+    }
 
-  var rcon = new Uint8Array([
+    this._s = new Uint8Array([
-    0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,
-    0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,
-    0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
-    0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
-    0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
-    0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6,
-    0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72,
-    0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
-    0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10,
-    0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e,
-    0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5,
-    0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
-    0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02,
-    0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d,
-    0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d,
-    0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
-    0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb,
-    0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,
-    0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,
-    0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
-    0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
-    0x74, 0xe8, 0xcb, 0x8d]);
-
-  var s = new Uint8Array([
       0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
       0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
       0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
@@ -679,9 +657,10 @@ var AES128Cipher = (function AES128CipherClosure() {
       0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
       0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
       0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
-    0xb0, 0x54, 0xbb, 0x16]);
+      0xb0, 0x54, 0xbb, 0x16,
+    ]);
 
-  var inv_s = new Uint8Array([
+    this._inv_s = new Uint8Array([
       0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
       0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
       0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32,
@@ -703,17 +682,10 @@ var AES128Cipher = (function AES128CipherClosure() {
       0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d,
       0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
       0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,
-    0x55, 0x21, 0x0c, 0x7d]);
+      0x55, 0x21, 0x0c, 0x7d,
+    ]);
 
-  var mixCol = new Uint8Array(256);
+    this._mix = new Uint32Array([
-  for (var i = 0; i < 256; i++) {
-    if (i < 128) {
-      mixCol[i] = i << 1;
-    } else {
-      mixCol[i] = (i << 1) ^ 0x1b;
-    }
-  }
-  var mix = new Uint32Array([
       0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927,
       0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45,
       0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb,
@@ -756,46 +728,36 @@ var AES128Cipher = (function AES128CipherClosure() {
       0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713,
       0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed,
       0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f,
-    0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3]);
+      0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3,
+    ]);
 
-  function _expandKey(cipherKey) {
+    this._mixCol = new Uint8Array(256);
-    var b = 176, result = new Uint8Array(b);
+    for (let i = 0; i < 256; i++) {
-    result.set(cipherKey);
+      if (i < 128) {
-    for (var j = 16, i = 1; j < b; ++i) {
+        this._mixCol[i] = i << 1;
-      // RotWord
+      } else {
-      var t1 = result[j - 3], t2 = result[j - 2],
+        this._mixCol[i] = (i << 1) ^ 0x1b;
-          t3 = result[j - 1], t4 = result[j - 4];
-      // SubWord
-      t1 = s[t1];
-      t2 = s[t2];
-      t3 = s[t3];
-      t4 = s[t4];
-      // Rcon
-      t1 = t1 ^ rcon[i];
-      for (var n = 0; n < 4; ++n) {
-        result[j] = (t1 ^= result[j - 16]);
-        j++;
-        result[j] = (t2 ^= result[j - 16]);
-        j++;
-        result[j] = (t3 ^= result[j - 16]);
-        j++;
-        result[j] = (t4 ^= result[j - 16]);
-        j++;
       }
     }
-    return result;
-  }
 
-  function _decrypt(input, key) {
+    this.buffer = new Uint8Array(16);
-    var state = new Uint8Array(16);
+    this.bufferPosition = 0;
+  }
+
+  _expandKey(cipherKey) {
+    unreachable('Cannot call `_expandKey` on the base class');
+  }
+
+  _decrypt(input, key) {
+    let t, u, v;
+    let state = new Uint8Array(16);
     state.set(input);
-    var i, j, k;
+
-    var t, u, v;
     // AddRoundKey
-    for (j = 0, k = KEY_SIZE; j < 16; ++j, ++k) {
+    for (let j = 0, k = this._keySize; j < 16; ++j, ++k) {
       state[j] ^= key[k];
     }
-    for (i = CYCLES_OF_REPETITION - 1; i >= 1; --i) {
+    for (let i = this._cyclesOfRepetition - 1; i >= 1; --i) {
       // InvShiftRows
       t = state[13];
       state[13] = state[9];
@@ -816,17 +778,19 @@ var AES128Cipher = (function AES128CipherClosure() {
       state[7] = u;
       state[3] = v;
       // InvSubBytes
-      for (j = 0; j < 16; ++j) {
+      for (let j = 0; j < 16; ++j) {
-        state[j] = inv_s[state[j]];
+        state[j] = this._inv_s[state[j]];
       }
       // AddRoundKey
-      for (j = 0, k = i * 16; j < 16; ++j, ++k) {
+      for (let j = 0, k = i * 16; j < 16; ++j, ++k) {
         state[j] ^= key[k];
       }
       // InvMixColumns
-      for (j = 0; j < 16; j += 4) {
+      for (let j = 0; j < 16; j += 4) {
-        var s0 = mix[state[j]], s1 = mix[state[j + 1]],
+        let s0 = this._mix[state[j]];
-            s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];
+        let s1 = this._mix[state[j + 1]];
+        let s2 = this._mix[state[j + 2]];
+        let s3 = this._mix[state[j + 3]];
         t = (s0 ^ (s1 >>> 8) ^ (s1 << 24) ^ (s2 >>> 16) ^ (s2 << 16) ^
             (s3 >>> 24) ^ (s3 << 8));
         state[j] = (t >>> 24) & 0xFF;
@@ -854,27 +818,30 @@ var AES128Cipher = (function AES128CipherClosure() {
     state[11] = t;
     state[7] = u;
     state[3] = v;
-    for (j = 0; j < 16; ++j) {
+    for (let j = 0; j < 16; ++j) {
       // InvSubBytes
-      state[j] = inv_s[state[j]];
+      state[j] = this._inv_s[state[j]];
       // AddRoundKey
       state[j] ^= key[j];
     }
     return state;
   }
 
-  function _encrypt(input, key) {
+  _encrypt(input, key) {
-    var t, u, v, i, j, k;
+    const s = this._s;
-    var state = new Uint8Array(16);
+
+    let t, u, v;
+    let state = new Uint8Array(16);
     state.set(input);
-    for (j = 0; j < 16; ++j) {
+
+    for (let j = 0; j < 16; ++j) {
       // AddRoundKey
       state[j] ^= key[j];
     }
 
-    for (i = 1; i < CYCLES_OF_REPETITION; i++) {
+    for (let i = 1; i < this._cyclesOfRepetition; i++) {
       // SubBytes
-      for (j = 0; j < 16; ++j) {
+      for (let j = 0; j < 16; ++j) {
         state[j] = s[state[j]];
       }
       // ShiftRows
@@ -897,23 +864,25 @@ var AES128Cipher = (function AES128CipherClosure() {
       state[11] = u;
       state[15] = t;
       // MixColumns
-      for (j = 0; j < 16; j += 4) {
+      for (let j = 0; j < 16; j += 4) {
-        var s0 = state[j + 0], s1 = state[j + 1];
+        let s0 = state[j + 0];
-        var s2 = state[j + 2], s3 = state[j + 3];
+        let s1 = state[j + 1];
+        let s2 = state[j + 2];
+        let s3 = state[j + 3];
         t = s0 ^ s1 ^ s2 ^ s3;
-        state[j + 0] ^= t ^ mixCol[s0 ^ s1];
+        state[j + 0] ^= t ^ this._mixCol[s0 ^ s1];
-        state[j + 1] ^= t ^ mixCol[s1 ^ s2];
+        state[j + 1] ^= t ^ this._mixCol[s1 ^ s2];
-        state[j + 2] ^= t ^ mixCol[s2 ^ s3];
+        state[j + 2] ^= t ^ this._mixCol[s2 ^ s3];
-        state[j + 3] ^= t ^ mixCol[s3 ^ s0];
+        state[j + 3] ^= t ^ this._mixCol[s3 ^ s0];
       }
       // AddRoundKey
-      for (j = 0, k = i * 16; j < 16; ++j, ++k) {
+      for (let j = 0, k = i * 16; j < 16; ++j, ++k) {
         state[j] ^= key[k];
       }
     }
 
     // SubBytes
-    for (j = 0; j < 16; ++j) {
+    for (let j = 0; j < 16; ++j) {
       state[j] = s[state[j]];
     }
     // ShiftRows
@@ -936,33 +905,27 @@ var AES128Cipher = (function AES128CipherClosure() {
     state[11] = u;
     state[15] = t;
     // AddRoundKey
-    for (j = 0, k = KEY_SIZE; j < 16; ++j, ++k) {
+    for (let j = 0, k = this._keySize; j < 16; ++j, ++k) {
       state[j] ^= key[k];
     }
     return state;
   }
 
-  function AES128Cipher(key) {
+  _decryptBlock2(data, finalize) {
-    this.key = _expandKey(key);
+    let sourceLength = data.length;
-    this.buffer = new Uint8Array(16);
+    let buffer = this.buffer, bufferLength = this.bufferPosition;
-    this.bufferPosition = 0;
+    let result = [], iv = this.iv;
-  }
 
-  function _decryptBlock2(data, finalize) {
+    for (let i = 0; i < sourceLength; ++i) {
-    var i, j, ii, sourceLength = data.length,
-        buffer = this.buffer, bufferLength = this.bufferPosition,
-        result = [], iv = this.iv;
-
-    for (i = 0; i < sourceLength; ++i) {
       buffer[bufferLength] = data[i];
       ++bufferLength;
       if (bufferLength < 16) {
         continue;
       }
       // buffer is full, decrypting
-      var plain = _decrypt(buffer, this.key);
+      let plain = this._decrypt(buffer, this._key);
       // xor-ing the IV vector to get plain text
-      for (j = 0; j < 16; ++j) {
+      for (let j = 0; j < 16; ++j) {
         plain[j] ^= iv[j];
       }
       iv = buffer;
@@ -975,16 +938,16 @@ var AES128Cipher = (function AES128CipherClosure() {
     this.bufferLength = bufferLength;
     this.iv = iv;
     if (result.length === 0) {
-      return new Uint8Array([]);
+      return new Uint8Array(0);
     }
     // combining plain text blocks into one
-    var outputLength = 16 * result.length;
+    let outputLength = 16 * result.length;
     if (finalize) {
       // undo a padding that is described in RFC 2898
-      var lastBlock = result[result.length - 1];
+      let lastBlock = result[result.length - 1];
-      var psLen = lastBlock[15];
+      let psLen = lastBlock[15];
       if (psLen <= 16) {
-        for (i = 15, ii = 16 - psLen; i >= ii; --i) {
+        for (let i = 15, ii = 16 - psLen; i >= ii; --i) {
           if (lastBlock[i] !== psLen) {
             // Invalid padding, assume that the block has no padding.
             psLen = 0;
@@ -995,52 +958,59 @@ var AES128Cipher = (function AES128CipherClosure() {
         result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
       }
     }
-    var output = new Uint8Array(outputLength);
+    let output = new Uint8Array(outputLength);
-    for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+    for (let i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
       output.set(result[i], j);
     }
     return output;
   }
 
-  AES128Cipher.prototype = {
+  decryptBlock(data, finalize, iv = null) {
-    decryptBlock(data, finalize) {
+    let sourceLength = data.length;
-      var i, sourceLength = data.length;
+    let buffer = this.buffer, bufferLength = this.bufferPosition;
-      var buffer = this.buffer, bufferLength = this.bufferPosition;
+    // If an IV is not supplied, wait for IV values. They are at the start
-      // waiting for IV values -- they are at the start of the stream
+    // of the stream.
-      for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {
+    if (iv) {
+      this.iv = iv;
+    } else {
+      for (let i = 0; bufferLength < 16 && i < sourceLength;
+           ++i, ++bufferLength) {
         buffer[bufferLength] = data[i];
       }
-      if (bufferLength < 16) {
+      if (bufferLength < 16) { // Need more data.
-        // need more data
         this.bufferLength = bufferLength;
-        return new Uint8Array([]);
+        return new Uint8Array(0);
       }
       this.iv = buffer;
+      data = data.subarray(16);
+    }
     this.buffer = new Uint8Array(16);
     this.bufferLength = 0;
     // starting decryption
-      this.decryptBlock = _decryptBlock2;
+    this.decryptBlock = this._decryptBlock2;
-      return this.decryptBlock(data.subarray(16), finalize);
+    return this.decryptBlock(data, finalize);
-    },
+  }
+
   encrypt(data, iv) {
-      var i, j, ii, sourceLength = data.length,
+    let sourceLength = data.length;
-          buffer = this.buffer, bufferLength = this.bufferPosition,
+    let buffer = this.buffer, bufferLength = this.bufferPosition;
-          result = [];
+    let result = [];
+
     if (!iv) {
       iv = new Uint8Array(16);
     }
-      for (i = 0; i < sourceLength; ++i) {
+    for (let i = 0; i < sourceLength; ++i) {
       buffer[bufferLength] = data[i];
       ++bufferLength;
       if (bufferLength < 16) {
         continue;
       }
-        for (j = 0; j < 16; ++j) {
+      for (let j = 0; j < 16; ++j) {
         buffer[j] ^= iv[j];
       }
 
       // buffer is full, encrypting
-        var cipher = _encrypt(buffer, this.key);
+      let cipher = this._encrypt(buffer, this._key);
       iv = cipher;
       result.push(cipher);
       buffer = new Uint8Array(16);
@@ -1051,133 +1021,109 @@ var AES128Cipher = (function AES128CipherClosure() {
     this.bufferLength = bufferLength;
     this.iv = iv;
     if (result.length === 0) {
-        return new Uint8Array([]);
+      return new Uint8Array(0);
     }
     // combining plain text blocks into one
-      var outputLength = 16 * result.length;
+    let outputLength = 16 * result.length;
-      var output = new Uint8Array(outputLength);
+    let output = new Uint8Array(outputLength);
-      for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+    for (let i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
       output.set(result[i], j);
     }
     return output;
-    },
-  };
-
-  return AES128Cipher;
-})();
-
-var AES256Cipher = (function AES256CipherClosure() {
-  const CYCLES_OF_REPETITION = 14;
-  const KEY_SIZE = 224; // bits
-
-  var s = new Uint8Array([
-    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
-    0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
-    0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
-    0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
-    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
-    0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
-    0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
-    0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
-    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
-    0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
-    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
-    0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
-    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
-    0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
-    0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
-    0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
-    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
-    0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
-    0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
-    0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
-    0xb0, 0x54, 0xbb, 0x16]);
-
-  var inv_s = new Uint8Array([
-    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
-    0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
-    0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32,
-    0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
-    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,
-    0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
-    0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50,
-    0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
-    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,
-    0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
-    0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41,
-    0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
-    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,
-    0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
-    0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b,
-    0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
-    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,
-    0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
-    0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d,
-    0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
-    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,
-    0x55, 0x21, 0x0c, 0x7d]);
-
-  var mixCol = new Uint8Array(256);
-  for (var i = 0; i < 256; i++) {
-    if (i < 128) {
-      mixCol[i] = i << 1;
-    } else {
-      mixCol[i] = (i << 1) ^ 0x1b;
   }
 }
-  var mix = new Uint32Array([
-    0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927,
-    0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45,
-    0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb,
-    0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381,
-    0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf,
-    0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66,
-    0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28,
-    0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012,
-    0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec,
-    0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e,
-    0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd,
-    0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7,
-    0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89,
-    0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b,
-    0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815,
-    0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f,
-    0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa,
-    0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8,
-    0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36,
-    0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c,
-    0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742,
-    0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea,
-    0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4,
-    0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e,
-    0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360,
-    0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502,
-    0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87,
-    0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd,
-    0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3,
-    0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621,
-    0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f,
-    0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55,
-    0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26,
-    0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844,
-    0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba,
-    0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480,
-    0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce,
-    0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67,
-    0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929,
-    0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713,
-    0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed,
-    0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f,
-    0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3]);
 
-  function _expandKey(cipherKey) {
+class AES128Cipher extends AESBaseCipher {
-    var b = 240, result = new Uint8Array(b);
+  constructor(key) {
-    var r = 1;
+    super();
 
+    this._cyclesOfRepetition = 10;
+    this._keySize = 160; // bits
+
+    this._rcon = new Uint8Array([
+      0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,
+      0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,
+      0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+      0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+      0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+      0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6,
+      0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72,
+      0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+      0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10,
+      0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e,
+      0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5,
+      0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+      0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02,
+      0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d,
+      0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d,
+      0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+      0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb,
+      0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,
+      0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,
+      0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+      0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+      0x74, 0xe8, 0xcb, 0x8d,
+    ]);
+
+    this._key = this._expandKey(key);
+  }
+
+  _expandKey(cipherKey) {
+    const b = 176;
+    const s = this._s;
+    const rcon = this._rcon;
+
+    let result = new Uint8Array(b);
     result.set(cipherKey);
-    for (var j = 32, i = 1; j < b; ++i) {
+
-      var t1, t2, t3, t4;
+    for (let j = 16, i = 1; j < b; ++i) {
+      // RotWord
+      let t1 = result[j - 3];
+      let t2 = result[j - 2];
+      let t3 = result[j - 1];
+      let t4 = result[j - 4];
+      // SubWord
+      t1 = s[t1];
+      t2 = s[t2];
+      t3 = s[t3];
+      t4 = s[t4];
+      // Rcon
+      t1 = t1 ^ rcon[i];
+      for (let n = 0; n < 4; ++n) {
+        result[j] = (t1 ^= result[j - 16]);
+        j++;
+        result[j] = (t2 ^= result[j - 16]);
+        j++;
+        result[j] = (t3 ^= result[j - 16]);
+        j++;
+        result[j] = (t4 ^= result[j - 16]);
+        j++;
+      }
+    }
+    return result;
+  }
+}
+
+class AES256Cipher extends AESBaseCipher {
+  constructor(key) {
+    super();
+
+    this._cyclesOfRepetition = 14;
+    this._keySize = 224; // bits
+
+    this._key = this._expandKey(key);
+  }
+
+  _expandKey(cipherKey) {
+    const b = 240;
+    const s = this._s;
+
+    let result = new Uint8Array(b);
+    result.set(cipherKey);
+
+    let r = 1;
+    let t1, t2, t3, t4;
+    for (let j = 32, i = 1; j < b; ++i) {
       if (j % 32 === 16) {
         t1 = s[t1];
         t2 = s[t2];
@@ -1201,7 +1147,7 @@ var AES256Cipher = (function AES256CipherClosure() {
         }
       }
 
-      for (var n = 0; n < 4; ++n) {
+      for (let n = 0; n < 4; ++n) {
         result[j] = (t1 ^= result[j - 32]);
         j++;
         result[j] = (t2 ^= result[j - 32]);
@@ -1214,292 +1160,7 @@ var AES256Cipher = (function AES256CipherClosure() {
     }
     return result;
   }
-
-  function _decrypt(input, key) {
-    var state = new Uint8Array(16);
-    state.set(input);
-    var i, j, k;
-    var t, u, v;
-    // AddRoundKey
-    for (j = 0, k = KEY_SIZE; j < 16; ++j, ++k) {
-      state[j] ^= key[k];
 }
-    for (i = CYCLES_OF_REPETITION - 1; i >= 1; --i) {
-      // InvShiftRows
-      t = state[13];
-      state[13] = state[9];
-      state[9] = state[5];
-      state[5] = state[1];
-      state[1] = t;
-      t = state[14];
-      u = state[10];
-      state[14] = state[6];
-      state[10] = state[2];
-      state[6] = t;
-      state[2] = u;
-      t = state[15];
-      u = state[11];
-      v = state[7];
-      state[15] = state[3];
-      state[11] = t;
-      state[7] = u;
-      state[3] = v;
-      // InvSubBytes
-      for (j = 0; j < 16; ++j) {
-        state[j] = inv_s[state[j]];
-      }
-      // AddRoundKey
-      for (j = 0, k = i * 16; j < 16; ++j, ++k) {
-        state[j] ^= key[k];
-      }
-      // InvMixColumns
-      for (j = 0; j < 16; j += 4) {
-        var s0 = mix[state[j]], s1 = mix[state[j + 1]],
-            s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];
-        t = (s0 ^ (s1 >>> 8) ^ (s1 << 24) ^ (s2 >>> 16) ^ (s2 << 16) ^
-            (s3 >>> 24) ^ (s3 << 8));
-        state[j] = (t >>> 24) & 0xFF;
-        state[j + 1] = (t >> 16) & 0xFF;
-        state[j + 2] = (t >> 8) & 0xFF;
-        state[j + 3] = t & 0xFF;
-      }
-    }
-    // InvShiftRows
-    t = state[13];
-    state[13] = state[9];
-    state[9] = state[5];
-    state[5] = state[1];
-    state[1] = t;
-    t = state[14];
-    u = state[10];
-    state[14] = state[6];
-    state[10] = state[2];
-    state[6] = t;
-    state[2] = u;
-    t = state[15];
-    u = state[11];
-    v = state[7];
-    state[15] = state[3];
-    state[11] = t;
-    state[7] = u;
-    state[3] = v;
-    for (j = 0; j < 16; ++j) {
-      // InvSubBytes
-      state[j] = inv_s[state[j]];
-      // AddRoundKey
-      state[j] ^= key[j];
-    }
-    return state;
-  }
-
-  function _encrypt(input, key) {
-    var t, u, v, i, j, k;
-    var state = new Uint8Array(16);
-    state.set(input);
-    for (j = 0; j < 16; ++j) {
-      // AddRoundKey
-      state[j] ^= key[j];
-    }
-
-    for (i = 1; i < CYCLES_OF_REPETITION; i++) {
-      // SubBytes
-      for (j = 0; j < 16; ++j) {
-        state[j] = s[state[j]];
-      }
-      // ShiftRows
-      v = state[1];
-      state[1] = state[5];
-      state[5] = state[9];
-      state[9] = state[13];
-      state[13] = v;
-      v = state[2];
-      u = state[6];
-      state[2] = state[10];
-      state[6] = state[14];
-      state[10] = v;
-      state[14] = u;
-      v = state[3];
-      u = state[7];
-      t = state[11];
-      state[3] = state[15];
-      state[7] = v;
-      state[11] = u;
-      state[15] = t;
-      // MixColumns
-      for (j = 0; j < 16; j += 4) {
-        var s0 = state[j + 0], s1 = state[j + 1];
-        var s2 = state[j + 2], s3 = state[j + 3];
-        t = s0 ^ s1 ^ s2 ^ s3;
-        state[j + 0] ^= t ^ mixCol[s0 ^ s1];
-        state[j + 1] ^= t ^ mixCol[s1 ^ s2];
-        state[j + 2] ^= t ^ mixCol[s2 ^ s3];
-        state[j + 3] ^= t ^ mixCol[s3 ^ s0];
-      }
-      // AddRoundKey
-      for (j = 0, k = i * 16; j < 16; ++j, ++k) {
-        state[j] ^= key[k];
-      }
-    }
-
-    // SubBytes
-    for (j = 0; j < 16; ++j) {
-      state[j] = s[state[j]];
-    }
-    // ShiftRows
-    v = state[1];
-    state[1] = state[5];
-    state[5] = state[9];
-    state[9] = state[13];
-    state[13] = v;
-    v = state[2];
-    u = state[6];
-    state[2] = state[10];
-    state[6] = state[14];
-    state[10] = v;
-    state[14] = u;
-    v = state[3];
-    u = state[7];
-    t = state[11];
-    state[3] = state[15];
-    state[7] = v;
-    state[11] = u;
-    state[15] = t;
-    // AddRoundKey
-    for (j = 0, k = KEY_SIZE; j < 16; ++j, ++k) {
-      state[j] ^= key[k];
-    }
-    return state;
-  }
-
-  function AES256Cipher(key) {
-    this.key = _expandKey(key);
-    this.buffer = new Uint8Array(16);
-    this.bufferPosition = 0;
-  }
-
-  function _decryptBlock2(data, finalize) {
-    var i, j, ii, sourceLength = data.length,
-        buffer = this.buffer, bufferLength = this.bufferPosition,
-        result = [], iv = this.iv;
-
-    for (i = 0; i < sourceLength; ++i) {
-      buffer[bufferLength] = data[i];
-      ++bufferLength;
-      if (bufferLength < 16) {
-        continue;
-      }
-      // buffer is full, decrypting
-      var plain = _decrypt(buffer, this.key);
-      // xor-ing the IV vector to get plain text
-      for (j = 0; j < 16; ++j) {
-        plain[j] ^= iv[j];
-      }
-      iv = buffer;
-      result.push(plain);
-      buffer = new Uint8Array(16);
-      bufferLength = 0;
-    }
-    // saving incomplete buffer
-    this.buffer = buffer;
-    this.bufferLength = bufferLength;
-    this.iv = iv;
-    if (result.length === 0) {
-      return new Uint8Array([]);
-    }
-    // combining plain text blocks into one
-    var outputLength = 16 * result.length;
-    if (finalize) {
-      // undo a padding that is described in RFC 2898
-      var lastBlock = result[result.length - 1];
-      var psLen = lastBlock[15];
-      if (psLen <= 16) {
-        for (i = 15, ii = 16 - psLen; i >= ii; --i) {
-          if (lastBlock[i] !== psLen) {
-            // Invalid padding, assume that the block has no padding.
-            psLen = 0;
-            break;
-          }
-        }
-        outputLength -= psLen;
-        result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
-      }
-    }
-    var output = new Uint8Array(outputLength);
-    for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
-      output.set(result[i], j);
-    }
-    return output;
-  }
-
-  AES256Cipher.prototype = {
-    decryptBlock(data, finalize, iv) {
-      var i, sourceLength = data.length;
-      var buffer = this.buffer, bufferLength = this.bufferPosition;
-      // if not supplied an IV wait for IV values
-      // they are at the start of the stream
-      if (iv) {
-        this.iv = iv;
-      } else {
-        for (i = 0; bufferLength < 16 &&
-             i < sourceLength; ++i, ++bufferLength) {
-          buffer[bufferLength] = data[i];
-        }
-        if (bufferLength < 16) { // Need more data.
-          this.bufferLength = bufferLength;
-          return new Uint8Array([]);
-        }
-        this.iv = buffer;
-        data = data.subarray(16);
-      }
-      this.buffer = new Uint8Array(16);
-      this.bufferLength = 0;
-      // starting decryption
-      this.decryptBlock = _decryptBlock2;
-      return this.decryptBlock(data, finalize);
-    },
-    encrypt(data, iv) {
-      var i, j, ii, sourceLength = data.length,
-          buffer = this.buffer, bufferLength = this.bufferPosition,
-          result = [];
-      if (!iv) {
-        iv = new Uint8Array(16);
-      }
-      for (i = 0; i < sourceLength; ++i) {
-        buffer[bufferLength] = data[i];
-        ++bufferLength;
-        if (bufferLength < 16) {
-          continue;
-        }
-        for (j = 0; j < 16; ++j) {
-          buffer[j] ^= iv[j];
-        }
-
-        // buffer is full, encrypting
-        var cipher = _encrypt(buffer, this.key);
-        iv = cipher;
-        result.push(cipher);
-        buffer = new Uint8Array(16);
-        bufferLength = 0;
-      }
-      // saving incomplete buffer
-      this.buffer = buffer;
-      this.bufferLength = bufferLength;
-      this.iv = iv;
-      if (result.length === 0) {
-        return new Uint8Array([]);
-      }
-      // combining plain text blocks into one
-      var outputLength = 16 * result.length;
-      var output = new Uint8Array(outputLength);
-      for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
-        output.set(result[i], j);
-      }
-      return output;
-    },
-  };
-
-  return AES256Cipher;
-})();
 
 var PDF17 = (function PDF17Closure() {