text: /**
   RC4 encryption decryption library
   @class RC4
   @constructor
   @return {Object} instantiated RC4
   **/
  function RC4(i_passkey) {
      this.m_passkey = i_passkey;
  };
  
  RC4.prototype = {
      constructor: RC4,
  
      /**
       Arcfour_algorithm
       @method _arcfour_crypt
       @param {Object} i_data
       @param {Object} i_key
       @return {String} _arcfour_byte_string
       **/
      _arcfour_crypt: function (i_data, i_key) {
          var self = this;
          var STATE_LENGTH = 256;
          var i, i1, i2, x, y, temp;
          var secretKey = new Array(STATE_LENGTH);
          var keyLen = i_key.length;
          var dataLen = i_data.length;
          var output = new Array(dataLen);
  
          i1 = 0;
          i2 = 0;
          x = 0;
          y = 0;
          for (i = 0; i < STATE_LENGTH; i++)
              secretKey[i] = i;
  
  
          for (i = 0; i < STATE_LENGTH; i++) {
              i2 = ((i_key.charCodeAt(i1) & 255) + secretKey[i] + i2) & 255;
              // swap
              temp = secretKey[i];
              secretKey[i] = secretKey[i2];
              secretKey[i2] = temp;
              i1 = (i1 + 1) % keyLen;
          }
  
          for (i = 0; i < dataLen; i++) {
              x = (x + 1) & 255;
              y = (secretKey[x] + y) & 255;
              // swap
              temp = secretKey[x];
              secretKey[x] = secretKey[y];
              secretKey[y] = temp;
              // xor
              output[i] = i_data.charCodeAt(i) ^ secretKey[(secretKey[x] + secretKey[y]) & 255];
          }
          return self._arcfour_byte_string(output);
      },
  
      /**
       Convert byte array into string.
       @method _arcfour_byte_string
       @param {Object} i_input
       @return {Object} output
       **/
      _arcfour_byte_string: function (i_input) {
          var self = this;
          var output = new String();
          for (var i = 0; i < i_input.length; i++) {
              output += String.fromCharCode(i_input[i]);
          }
          return output;
      },
  
      /**
       Get the hex representation of an array of bytes
       @method _arcfour_hex_encode
       @param {Object} i_input
       @return {Object} output
       **/
      _arcfour_hex_encode: function (i_input) {
          var self = this;
          var hex_digits = "0123456789abcdef";
          var output = new String();
          for (var i = 0; i < i_input.length; i++) {
              output += hex_digits.charAt((i_input.charCodeAt(i) >>> 4) & 15);
              output += hex_digits.charAt(i_input.charCodeAt(i) & 15);
          }
          return output;
      },
  
      /**
       Decode hex string
       @method _arcfour_hex_decode
       @param {Object} i_input
       @return {Object} output
       **/
      _arcfour_hex_decode: function (i_input) {
          var self = this;
          var left, right, index;
          var output = new Array(i_input.length / 2);
          for (var i = 0; i < i_input.length; i += 2) {
              left = i_input.charCodeAt(i);
              right = i_input.charCodeAt(i + 1);
              index = i / 2;
              if (left < 97)  // left < 'a'
                  output[index] = ((left - 48) << 4);  // left - '0'
              else
                  output[index] = ((left - 97 + 10) << 4);
              if (right < 97)
                  output[index] += (right - 48);
              else
                  output[index] += (right - 97 + 10);
          }
          return self._arcfour_byte_string(output);
      },
  
      /**
       Generate a key in case we need a new one
       @method _genKey
       @return {Number} new ley
       **/
      _genKey: function () {
          var self = this;
          var key = new Array();
          var i = 0;
          var n;
          while (i < 16) {
              n = Math.ceil(Math.random() * 255);
              key[i] = n;
              i++;
          }
          return self._arcfour_hex_encode(self._arcfour_byte_string(key));
      },
  
      /**
       Execute an encryption using pass
       @method doEncrypt
       @param {String} i_plaintext
       @return {String} encrypted dtaa
       **/
      doEncrypt: function (i_plaintext) {
          var self = this;
          if (i_plaintext.length > 0) {
              return self._arcfour_hex_encode(self._arcfour_crypt(i_plaintext, self._arcfour_hex_decode(self.m_passkey)));
          }
      },
  
      /**
       Execute an decryption using pass on i_value
       @method doDecrypt
       @param {String} plaintext
       @return {String} decrypted i_value
       **/
      doDecrypt: function (i_value) {
          var self = this;
          var ciphertext = self._arcfour_hex_decode(i_value);
          if (ciphertext.length > 0) {
              return self._arcfour_crypt(ciphertext, self._arcfour_hex_decode(self.m_passkey));
          }
      }
  }
  
  
  
  