text: import BlockCipher from '../Helpers/BlockCipher';
  
  // Lookup tables
  var SBOX = [];
  var INV_SBOX = [];
  var SUB_MIX_0 = [];
  var SUB_MIX_1 = [];
  var SUB_MIX_2 = [];
  var SUB_MIX_3 = [];
  var INV_SUB_MIX_0 = [];
  var INV_SUB_MIX_1 = [];
  var INV_SUB_MIX_2 = [];
  var INV_SUB_MIX_3 = [];
  
  // Compute lookup tables
  (function () {
  	// Compute double table
  	var d = [];
  	for (var i = 0; i < 256; i++) {
  		if (i < 128) {
  			d[i] = i << 1;
  		} else {
  			d[i] = (i << 1) ^ 0x11b;
  		}
  	}
  
  	// Walk GF(2^8)
  	var x = 0;
  	var xi = 0;
  	for (var i = 0; i < 256; i++) {
  		// Compute sbox
  		var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
  		sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
  		SBOX[x] = sx;
  		INV_SBOX[sx] = x;
  
  		// Compute multiplication
  		var x2 = d[x];
  		var x4 = d[x2];
  		var x8 = d[x4];
  
  		// Compute sub bytes, mix columns tables
  		var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
  		SUB_MIX_0[x] = (t << 24) | (t >>> 8);
  		SUB_MIX_1[x] = (t << 16) | (t >>> 16);
  		SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
  		SUB_MIX_3[x] = t;
  
  		// Compute inv sub bytes, inv mix columns tables
  		var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
  		INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
  		INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
  		INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
  		INV_SUB_MIX_3[sx] = t;
  
  		// Compute next counter
  		if (!x) {
  			x = xi = 1;
  		} else {
  			x = x2 ^ d[d[d[x8 ^ x2]]];
  			xi ^= d[d[xi]];
  		}
  	}
  }());
  
  // Precomputed Rcon lookup
  var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
  
  class AES {
  	constructor() {}
  
  	algo() {
  		return new BlockCipher().extend({
  			_doReset: function () {
  				// Shortcuts
  				var key = this._key;
  				var keyWords = key.words;
  				var keySize = key.sigBytes / 4;
  
  				// Compute number of rounds
  				var nRounds = this._nRounds = keySize + 6
  
  				// Compute number of key schedule rows
  				var ksRows = (nRounds + 1) * 4;
  
  				// Compute key schedule
  				var keySchedule = this._keySchedule = [];
  				for (var ksRow = 0; ksRow < ksRows; ksRow++) {
  					if (ksRow < keySize) {
  						keySchedule[ksRow] = keyWords[ksRow];
  					} else {
  						var t = keySchedule[ksRow - 1];
  
  						if (!(ksRow % keySize)) {
  							// Rot word
  							t = (t << 8) | (t >>> 24);
  
  							// Sub word
  							t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
  
  							// Mix Rcon
  							t ^= RCON[(ksRow / keySize) | 0] << 24;
  						} else if (keySize > 6 && ksRow % keySize == 4) {
  							// Sub word
  							t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
  						}
  
  						keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
  					}
  				}
  
  				// Compute inv key schedule
  				var invKeySchedule = this._invKeySchedule = [];
  				for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
  					var ksRow = ksRows - invKsRow;
  
  					if (invKsRow % 4) {
  						var t = keySchedule[ksRow];
  					} else {
  						var t = keySchedule[ksRow - 4];
  					}
  
  					if (invKsRow < 4 || ksRow <= 4) {
  						invKeySchedule[invKsRow] = t;
  					} else {
  						invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
  												   INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
  					}
  				}
  			},
  
  			encryptBlock: function (M, offset) {
  				this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
  			},
  
  			decryptBlock: function (M, offset) {
  				// Swap 2nd and 4th rows
  				var t = M[offset + 1];
  				M[offset + 1] = M[offset + 3];
  				M[offset + 3] = t;
  
  				this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
  
  				// Inv swap 2nd and 4th rows
  				var t = M[offset + 1];
  				M[offset + 1] = M[offset + 3];
  				M[offset + 3] = t;
  			},
  
  			_doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
  				// Shortcut
  				var nRounds = this._nRounds;
  
  				// Get input, add round key
  				var s0 = M[offset]     ^ keySchedule[0];
  				var s1 = M[offset + 1] ^ keySchedule[1];
  				var s2 = M[offset + 2] ^ keySchedule[2];
  				var s3 = M[offset + 3] ^ keySchedule[3];
  
  				// Key schedule row counter
  				var ksRow = 4;
  
  				// Rounds
  				for (var round = 1; round < nRounds; round++) {
  					// Shift rows, sub bytes, mix columns, add round key
  					var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
  					var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
  					var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
  					var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
  
  					// Update state
  					s0 = t0;
  					s1 = t1;
  					s2 = t2;
  					s3 = t3;
  				}
  
  				// Shift rows, sub bytes, add round key
  				var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
  				var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
  				var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
  				var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
  
  				// Set output
  				M[offset]     = t0;
  				M[offset + 1] = t1;
  				M[offset + 2] = t2;
  				M[offset + 3] = t3;
  			},
  
  			keySize: 256/32
  		});
  	}
  }
  
  export default AES;
  
  