github.com/ebakus/go-ebakus@v1.0.5-0.20200520105415-dbccef9ec421/internal/jsre/deps/web3.js (about)

     1  require=(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){
     2  module.exports=[
     3    {
     4      "constant": true,
     5      "inputs": [
     6        {
     7          "name": "_owner",
     8          "type": "address"
     9        }
    10      ],
    11      "name": "name",
    12      "outputs": [
    13        {
    14          "name": "o_name",
    15          "type": "bytes32"
    16        }
    17      ],
    18      "type": "function"
    19    },
    20    {
    21      "constant": true,
    22      "inputs": [
    23        {
    24          "name": "_name",
    25          "type": "bytes32"
    26        }
    27      ],
    28      "name": "owner",
    29      "outputs": [
    30        {
    31          "name": "",
    32          "type": "address"
    33        }
    34      ],
    35      "type": "function"
    36    },
    37    {
    38      "constant": true,
    39      "inputs": [
    40        {
    41          "name": "_name",
    42          "type": "bytes32"
    43        }
    44      ],
    45      "name": "content",
    46      "outputs": [
    47        {
    48          "name": "",
    49          "type": "bytes32"
    50        }
    51      ],
    52      "type": "function"
    53    },
    54    {
    55      "constant": true,
    56      "inputs": [
    57        {
    58          "name": "_name",
    59          "type": "bytes32"
    60        }
    61      ],
    62      "name": "addr",
    63      "outputs": [
    64        {
    65          "name": "",
    66          "type": "address"
    67        }
    68      ],
    69      "type": "function"
    70    },
    71    {
    72      "constant": false,
    73      "inputs": [
    74        {
    75          "name": "_name",
    76          "type": "bytes32"
    77        }
    78      ],
    79      "name": "reserve",
    80      "outputs": [],
    81      "type": "function"
    82    },
    83    {
    84      "constant": true,
    85      "inputs": [
    86        {
    87          "name": "_name",
    88          "type": "bytes32"
    89        }
    90      ],
    91      "name": "subRegistrar",
    92      "outputs": [
    93        {
    94          "name": "",
    95          "type": "address"
    96        }
    97      ],
    98      "type": "function"
    99    },
   100    {
   101      "constant": false,
   102      "inputs": [
   103        {
   104          "name": "_name",
   105          "type": "bytes32"
   106        },
   107        {
   108          "name": "_newOwner",
   109          "type": "address"
   110        }
   111      ],
   112      "name": "transfer",
   113      "outputs": [],
   114      "type": "function"
   115    },
   116    {
   117      "constant": false,
   118      "inputs": [
   119        {
   120          "name": "_name",
   121          "type": "bytes32"
   122        },
   123        {
   124          "name": "_registrar",
   125          "type": "address"
   126        }
   127      ],
   128      "name": "setSubRegistrar",
   129      "outputs": [],
   130      "type": "function"
   131    },
   132    {
   133      "constant": false,
   134      "inputs": [],
   135      "name": "Registrar",
   136      "outputs": [],
   137      "type": "function"
   138    },
   139    {
   140      "constant": false,
   141      "inputs": [
   142        {
   143          "name": "_name",
   144          "type": "bytes32"
   145        },
   146        {
   147          "name": "_a",
   148          "type": "address"
   149        },
   150        {
   151          "name": "_primary",
   152          "type": "bool"
   153        }
   154      ],
   155      "name": "setAddress",
   156      "outputs": [],
   157      "type": "function"
   158    },
   159    {
   160      "constant": false,
   161      "inputs": [
   162        {
   163          "name": "_name",
   164          "type": "bytes32"
   165        },
   166        {
   167          "name": "_content",
   168          "type": "bytes32"
   169        }
   170      ],
   171      "name": "setContent",
   172      "outputs": [],
   173      "type": "function"
   174    },
   175    {
   176      "constant": false,
   177      "inputs": [
   178        {
   179          "name": "_name",
   180          "type": "bytes32"
   181        }
   182      ],
   183      "name": "disown",
   184      "outputs": [],
   185      "type": "function"
   186    },
   187    {
   188      "anonymous": false,
   189      "inputs": [
   190        {
   191          "indexed": true,
   192          "name": "_name",
   193          "type": "bytes32"
   194        },
   195        {
   196          "indexed": false,
   197          "name": "_winner",
   198          "type": "address"
   199        }
   200      ],
   201      "name": "AuctionEnded",
   202      "type": "event"
   203    },
   204    {
   205      "anonymous": false,
   206      "inputs": [
   207        {
   208          "indexed": true,
   209          "name": "_name",
   210          "type": "bytes32"
   211        },
   212        {
   213          "indexed": false,
   214          "name": "_bidder",
   215          "type": "address"
   216        },
   217        {
   218          "indexed": false,
   219          "name": "_value",
   220          "type": "uint256"
   221        }
   222      ],
   223      "name": "NewBid",
   224      "type": "event"
   225    },
   226    {
   227      "anonymous": false,
   228      "inputs": [
   229        {
   230          "indexed": true,
   231          "name": "name",
   232          "type": "bytes32"
   233        }
   234      ],
   235      "name": "Changed",
   236      "type": "event"
   237    },
   238    {
   239      "anonymous": false,
   240      "inputs": [
   241        {
   242          "indexed": true,
   243          "name": "name",
   244          "type": "bytes32"
   245        },
   246        {
   247          "indexed": true,
   248          "name": "addr",
   249          "type": "address"
   250        }
   251      ],
   252      "name": "PrimaryChanged",
   253      "type": "event"
   254    }
   255  ]
   256  
   257  },{}],2:[function(require,module,exports){
   258  module.exports=[
   259    {
   260      "constant": true,
   261      "inputs": [
   262        {
   263          "name": "_name",
   264          "type": "bytes32"
   265        }
   266      ],
   267      "name": "owner",
   268      "outputs": [
   269        {
   270          "name": "",
   271          "type": "address"
   272        }
   273      ],
   274      "type": "function"
   275    },
   276    {
   277      "constant": false,
   278      "inputs": [
   279        {
   280          "name": "_name",
   281          "type": "bytes32"
   282        },
   283        {
   284          "name": "_refund",
   285          "type": "address"
   286        }
   287      ],
   288      "name": "disown",
   289      "outputs": [],
   290      "type": "function"
   291    },
   292    {
   293      "constant": true,
   294      "inputs": [
   295        {
   296          "name": "_name",
   297          "type": "bytes32"
   298        }
   299      ],
   300      "name": "addr",
   301      "outputs": [
   302        {
   303          "name": "",
   304          "type": "address"
   305        }
   306      ],
   307      "type": "function"
   308    },
   309    {
   310      "constant": false,
   311      "inputs": [
   312        {
   313          "name": "_name",
   314          "type": "bytes32"
   315        }
   316      ],
   317      "name": "reserve",
   318      "outputs": [],
   319      "type": "function"
   320    },
   321    {
   322      "constant": false,
   323      "inputs": [
   324        {
   325          "name": "_name",
   326          "type": "bytes32"
   327        },
   328        {
   329          "name": "_newOwner",
   330          "type": "address"
   331        }
   332      ],
   333      "name": "transfer",
   334      "outputs": [],
   335      "type": "function"
   336    },
   337    {
   338      "constant": false,
   339      "inputs": [
   340        {
   341          "name": "_name",
   342          "type": "bytes32"
   343        },
   344        {
   345          "name": "_a",
   346          "type": "address"
   347        }
   348      ],
   349      "name": "setAddr",
   350      "outputs": [],
   351      "type": "function"
   352    },
   353    {
   354      "anonymous": false,
   355      "inputs": [
   356        {
   357          "indexed": true,
   358          "name": "name",
   359          "type": "bytes32"
   360        }
   361      ],
   362      "name": "Changed",
   363      "type": "event"
   364    }
   365  ]
   366  
   367  },{}],3:[function(require,module,exports){
   368  module.exports=[
   369    {
   370      "constant": false,
   371      "inputs": [
   372        {
   373          "name": "from",
   374          "type": "bytes32"
   375        },
   376        {
   377          "name": "to",
   378          "type": "address"
   379        },
   380        {
   381          "name": "value",
   382          "type": "uint256"
   383        }
   384      ],
   385      "name": "transfer",
   386      "outputs": [],
   387      "type": "function"
   388    },
   389    {
   390      "constant": false,
   391      "inputs": [
   392        {
   393          "name": "from",
   394          "type": "bytes32"
   395        },
   396        {
   397          "name": "to",
   398          "type": "address"
   399        },
   400        {
   401          "name": "indirectId",
   402          "type": "bytes32"
   403        },
   404        {
   405          "name": "value",
   406          "type": "uint256"
   407        }
   408      ],
   409      "name": "icapTransfer",
   410      "outputs": [],
   411      "type": "function"
   412    },
   413    {
   414      "constant": false,
   415      "inputs": [
   416        {
   417          "name": "to",
   418          "type": "bytes32"
   419        }
   420      ],
   421      "name": "deposit",
   422      "outputs": [],
   423      "payable": true,
   424      "type": "function"
   425    },
   426    {
   427      "anonymous": false,
   428      "inputs": [
   429        {
   430          "indexed": true,
   431          "name": "from",
   432          "type": "address"
   433        },
   434        {
   435          "indexed": false,
   436          "name": "value",
   437          "type": "uint256"
   438        }
   439      ],
   440      "name": "AnonymousDeposit",
   441      "type": "event"
   442    },
   443    {
   444      "anonymous": false,
   445      "inputs": [
   446        {
   447          "indexed": true,
   448          "name": "from",
   449          "type": "address"
   450        },
   451        {
   452          "indexed": true,
   453          "name": "to",
   454          "type": "bytes32"
   455        },
   456        {
   457          "indexed": false,
   458          "name": "value",
   459          "type": "uint256"
   460        }
   461      ],
   462      "name": "Deposit",
   463      "type": "event"
   464    },
   465    {
   466      "anonymous": false,
   467      "inputs": [
   468        {
   469          "indexed": true,
   470          "name": "from",
   471          "type": "bytes32"
   472        },
   473        {
   474          "indexed": true,
   475          "name": "to",
   476          "type": "address"
   477        },
   478        {
   479          "indexed": false,
   480          "name": "value",
   481          "type": "uint256"
   482        }
   483      ],
   484      "name": "Transfer",
   485      "type": "event"
   486    },
   487    {
   488      "anonymous": false,
   489      "inputs": [
   490        {
   491          "indexed": true,
   492          "name": "from",
   493          "type": "bytes32"
   494        },
   495        {
   496          "indexed": true,
   497          "name": "to",
   498          "type": "address"
   499        },
   500        {
   501          "indexed": false,
   502          "name": "indirectId",
   503          "type": "bytes32"
   504        },
   505        {
   506          "indexed": false,
   507          "name": "value",
   508          "type": "uint256"
   509        }
   510      ],
   511      "name": "IcapTransfer",
   512      "type": "event"
   513    }
   514  ]
   515  
   516  },{}],4:[function(require,module,exports){
   517  var f = require('./formatters');
   518  var SolidityType = require('./type');
   519  
   520  /**
   521   * SolidityTypeAddress is a prootype that represents address type
   522   * It matches:
   523   * address
   524   * address[]
   525   * address[4]
   526   * address[][]
   527   * address[3][]
   528   * address[][6][], ...
   529   */
   530  var SolidityTypeAddress = function () {
   531      this._inputFormatter = f.formatInputInt;
   532      this._outputFormatter = f.formatOutputAddress;
   533  };
   534  
   535  SolidityTypeAddress.prototype = new SolidityType({});
   536  SolidityTypeAddress.prototype.constructor = SolidityTypeAddress;
   537  
   538  SolidityTypeAddress.prototype.isType = function (name) {
   539      return !!name.match(/address(\[([0-9]*)\])?/);
   540  };
   541  
   542  module.exports = SolidityTypeAddress;
   543  
   544  },{"./formatters":9,"./type":14}],5:[function(require,module,exports){
   545  var f = require('./formatters');
   546  var SolidityType = require('./type');
   547  
   548  /**
   549   * SolidityTypeBool is a prootype that represents bool type
   550   * It matches:
   551   * bool
   552   * bool[]
   553   * bool[4]
   554   * bool[][]
   555   * bool[3][]
   556   * bool[][6][], ...
   557   */
   558  var SolidityTypeBool = function () {
   559      this._inputFormatter = f.formatInputBool;
   560      this._outputFormatter = f.formatOutputBool;
   561  };
   562  
   563  SolidityTypeBool.prototype = new SolidityType({});
   564  SolidityTypeBool.prototype.constructor = SolidityTypeBool;
   565  
   566  SolidityTypeBool.prototype.isType = function (name) {
   567      return !!name.match(/^bool(\[([0-9]*)\])*$/);
   568  };
   569  
   570  module.exports = SolidityTypeBool;
   571  
   572  },{"./formatters":9,"./type":14}],6:[function(require,module,exports){
   573  var f = require('./formatters');
   574  var SolidityType = require('./type');
   575  
   576  /**
   577   * SolidityTypeBytes is a prototype that represents the bytes type.
   578   * It matches:
   579   * bytes
   580   * bytes[]
   581   * bytes[4]
   582   * bytes[][]
   583   * bytes[3][]
   584   * bytes[][6][], ...
   585   * bytes32
   586   * bytes8[4]
   587   * bytes[3][]
   588   */
   589  var SolidityTypeBytes = function () {
   590      this._inputFormatter = f.formatInputBytes;
   591      this._outputFormatter = f.formatOutputBytes;
   592  };
   593  
   594  SolidityTypeBytes.prototype = new SolidityType({});
   595  SolidityTypeBytes.prototype.constructor = SolidityTypeBytes;
   596  
   597  SolidityTypeBytes.prototype.isType = function (name) {
   598      return !!name.match(/^bytes([0-9]{1,})(\[([0-9]*)\])*$/);
   599  };
   600  
   601  module.exports = SolidityTypeBytes;
   602  
   603  },{"./formatters":9,"./type":14}],7:[function(require,module,exports){
   604  /*
   605      This file is part of web3.js.
   606  
   607      web3.js is free software: you can redistribute it and/or modify
   608      it under the terms of the GNU Lesser General Public License as published by
   609      the Free Software Foundation, either version 3 of the License, or
   610      (at your option) any later version.
   611  
   612      web3.js is distributed in the hope that it will be useful,
   613      but WITHOUT ANY WARRANTY; without even the implied warranty of
   614      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   615      GNU Lesser General Public License for more details.
   616  
   617      You should have received a copy of the GNU Lesser General Public License
   618      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
   619  */
   620  /**
   621   * @file coder.js
   622   * @author Marek Kotewicz <marek@ethdev.com>
   623   * @date 2015
   624   */
   625  
   626  var f = require('./formatters');
   627  
   628  var SolidityTypeAddress = require('./address');
   629  var SolidityTypeBool = require('./bool');
   630  var SolidityTypeInt = require('./int');
   631  var SolidityTypeUInt = require('./uint');
   632  var SolidityTypeDynamicBytes = require('./dynamicbytes');
   633  var SolidityTypeString = require('./string');
   634  var SolidityTypeReal = require('./real');
   635  var SolidityTypeUReal = require('./ureal');
   636  var SolidityTypeBytes = require('./bytes');
   637  
   638  var isDynamic = function (solidityType, type) {
   639     return solidityType.isDynamicType(type) ||
   640            solidityType.isDynamicArray(type);
   641  };
   642  
   643  /**
   644   * SolidityCoder prototype should be used to encode/decode solidity params of any type
   645   */
   646  var SolidityCoder = function (types) {
   647      this._types = types;
   648  };
   649  
   650  /**
   651   * This method should be used to transform type to SolidityType
   652   *
   653   * @method _requireType
   654   * @param {String} type
   655   * @returns {SolidityType}
   656   * @throws {Error} throws if no matching type is found
   657   */
   658  SolidityCoder.prototype._requireType = function (type) {
   659      var solidityType = this._types.filter(function (t) {
   660          return t.isType(type);
   661      })[0];
   662  
   663      if (!solidityType) {
   664          throw Error('invalid solidity type!: ' + type);
   665      }
   666  
   667      return solidityType;
   668  };
   669  
   670  /**
   671   * Should be used to encode plain param
   672   *
   673   * @method encodeParam
   674   * @param {String} type
   675   * @param {Object} plain param
   676   * @return {String} encoded plain param
   677   */
   678  SolidityCoder.prototype.encodeParam = function (type, param) {
   679      return this.encodeParams([type], [param]);
   680  };
   681  
   682  /**
   683   * Should be used to encode list of params
   684   *
   685   * @method encodeParams
   686   * @param {Array} types
   687   * @param {Array} params
   688   * @return {String} encoded list of params
   689   */
   690  SolidityCoder.prototype.encodeParams = function (types, params) {
   691      var solidityTypes = this.getSolidityTypes(types);
   692  
   693      var encodeds = solidityTypes.map(function (solidityType, index) {
   694          return solidityType.encode(params[index], types[index]);
   695      });
   696  
   697      var dynamicOffset = solidityTypes.reduce(function (acc, solidityType, index) {
   698          var staticPartLength = solidityType.staticPartLength(types[index]);
   699          var roundedStaticPartLength = Math.floor((staticPartLength + 31) / 32) * 32;
   700  
   701          return acc + (isDynamic(solidityTypes[index], types[index]) ?
   702              32 :
   703              roundedStaticPartLength);
   704      }, 0);
   705  
   706      var result = this.encodeMultiWithOffset(types, solidityTypes, encodeds, dynamicOffset);
   707  
   708      return result;
   709  };
   710  
   711  SolidityCoder.prototype.encodeMultiWithOffset = function (types, solidityTypes, encodeds, dynamicOffset) {
   712      var result = "";
   713      var self = this;
   714  
   715      types.forEach(function (type, i) {
   716          if (isDynamic(solidityTypes[i], types[i])) {
   717              result += f.formatInputInt(dynamicOffset).encode();
   718              var e = self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset);
   719              dynamicOffset += e.length / 2;
   720          } else {
   721              // don't add length to dynamicOffset. it's already counted
   722              result += self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset);
   723          }
   724  
   725          // TODO: figure out nested arrays
   726      });
   727  
   728      types.forEach(function (type, i) {
   729          if (isDynamic(solidityTypes[i], types[i])) {
   730              var e = self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset);
   731              dynamicOffset += e.length / 2;
   732              result += e;
   733          }
   734      });
   735      return result;
   736  };
   737  
   738  // TODO: refactor whole encoding!
   739  SolidityCoder.prototype.encodeWithOffset = function (type, solidityType, encoded, offset) {
   740      var self = this;
   741      if (solidityType.isDynamicArray(type)) {
   742          return (function () {
   743              // offset was already set
   744              var nestedName = solidityType.nestedName(type);
   745              var nestedStaticPartLength = solidityType.staticPartLength(nestedName);
   746              var result = encoded[0];
   747  
   748              (function () {
   749                  var previousLength = 2; // in int
   750                  if (solidityType.isDynamicArray(nestedName)) {
   751                      for (var i = 1; i < encoded.length; i++) {
   752                          previousLength += +(encoded[i - 1])[0] || 0;
   753                          result += f.formatInputInt(offset + i * nestedStaticPartLength + previousLength * 32).encode();
   754                      }
   755                  }
   756              })();
   757  
   758              // first element is length, skip it
   759              (function () {
   760                  for (var i = 0; i < encoded.length - 1; i++) {
   761                      var additionalOffset = result / 2;
   762                      result += self.encodeWithOffset(nestedName, solidityType, encoded[i + 1], offset +  additionalOffset);
   763                  }
   764              })();
   765  
   766              return result;
   767          })();
   768  
   769      } else if (solidityType.isStaticArray(type)) {
   770          return (function () {
   771              var nestedName = solidityType.nestedName(type);
   772              var nestedStaticPartLength = solidityType.staticPartLength(nestedName);
   773              var result = "";
   774  
   775  
   776              if (solidityType.isDynamicArray(nestedName)) {
   777                  (function () {
   778                      var previousLength = 0; // in int
   779                      for (var i = 0; i < encoded.length; i++) {
   780                          // calculate length of previous item
   781                          previousLength += +(encoded[i - 1] || [])[0] || 0;
   782                          result += f.formatInputInt(offset + i * nestedStaticPartLength + previousLength * 32).encode();
   783                      }
   784                  })();
   785              }
   786  
   787              (function () {
   788                  for (var i = 0; i < encoded.length; i++) {
   789                      var additionalOffset = result / 2;
   790                      result += self.encodeWithOffset(nestedName, solidityType, encoded[i], offset + additionalOffset);
   791                  }
   792              })();
   793  
   794              return result;
   795          })();
   796      }
   797  
   798      return encoded;
   799  };
   800  
   801  /**
   802   * Should be used to decode bytes to plain param
   803   *
   804   * @method decodeParam
   805   * @param {String} type
   806   * @param {String} bytes
   807   * @return {Object} plain param
   808   */
   809  SolidityCoder.prototype.decodeParam = function (type, bytes) {
   810      return this.decodeParams([type], bytes)[0];
   811  };
   812  
   813  /**
   814   * Should be used to decode list of params
   815   *
   816   * @method decodeParam
   817   * @param {Array} types
   818   * @param {String} bytes
   819   * @return {Array} array of plain params
   820   */
   821  SolidityCoder.prototype.decodeParams = function (types, bytes) {
   822      var solidityTypes = this.getSolidityTypes(types);
   823      var offsets = this.getOffsets(types, solidityTypes);
   824  
   825      return solidityTypes.map(function (solidityType, index) {
   826          return solidityType.decode(bytes, offsets[index],  types[index], index);
   827      });
   828  };
   829  
   830  SolidityCoder.prototype.getOffsets = function (types, solidityTypes) {
   831      var lengths =  solidityTypes.map(function (solidityType, index) {
   832          return solidityType.staticPartLength(types[index]);
   833      });
   834  
   835      for (var i = 1; i < lengths.length; i++) {
   836           // sum with length of previous element
   837          lengths[i] += lengths[i - 1];
   838      }
   839  
   840      return lengths.map(function (length, index) {
   841          // remove the current length, so the length is sum of previous elements
   842          var staticPartLength = solidityTypes[index].staticPartLength(types[index]);
   843          return length - staticPartLength;
   844      });
   845  };
   846  
   847  SolidityCoder.prototype.getSolidityTypes = function (types) {
   848      var self = this;
   849      return types.map(function (type) {
   850          return self._requireType(type);
   851      });
   852  };
   853  
   854  var coder = new SolidityCoder([
   855      new SolidityTypeAddress(),
   856      new SolidityTypeBool(),
   857      new SolidityTypeInt(),
   858      new SolidityTypeUInt(),
   859      new SolidityTypeDynamicBytes(),
   860      new SolidityTypeBytes(),
   861      new SolidityTypeString(),
   862      new SolidityTypeReal(),
   863      new SolidityTypeUReal()
   864  ]);
   865  
   866  module.exports = coder;
   867  
   868  },{"./address":4,"./bool":5,"./bytes":6,"./dynamicbytes":8,"./formatters":9,"./int":10,"./real":12,"./string":13,"./uint":15,"./ureal":16}],8:[function(require,module,exports){
   869  var f = require('./formatters');
   870  var SolidityType = require('./type');
   871  
   872  var SolidityTypeDynamicBytes = function () {
   873      this._inputFormatter = f.formatInputDynamicBytes;
   874      this._outputFormatter = f.formatOutputDynamicBytes;
   875  };
   876  
   877  SolidityTypeDynamicBytes.prototype = new SolidityType({});
   878  SolidityTypeDynamicBytes.prototype.constructor = SolidityTypeDynamicBytes;
   879  
   880  SolidityTypeDynamicBytes.prototype.isType = function (name) {
   881      return !!name.match(/^bytes(\[([0-9]*)\])*$/);
   882  };
   883  
   884  SolidityTypeDynamicBytes.prototype.isDynamicType = function () {
   885      return true;
   886  };
   887  
   888  module.exports = SolidityTypeDynamicBytes;
   889  
   890  },{"./formatters":9,"./type":14}],9:[function(require,module,exports){
   891  /*
   892      This file is part of web3.js.
   893  
   894      web3.js is free software: you can redistribute it and/or modify
   895      it under the terms of the GNU Lesser General Public License as published by
   896      the Free Software Foundation, either version 3 of the License, or
   897      (at your option) any later version.
   898  
   899      web3.js is distributed in the hope that it will be useful,
   900      but WITHOUT ANY WARRANTY; without even the implied warranty of
   901      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   902      GNU Lesser General Public License for more details.
   903  
   904      You should have received a copy of the GNU Lesser General Public License
   905      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
   906  */
   907  /**
   908   * @file formatters.js
   909   * @author Marek Kotewicz <marek@ethdev.com>
   910   * @date 2015
   911   */
   912  
   913  var BigNumber = require('bignumber.js');
   914  var utils = require('../utils/utils');
   915  var c = require('../utils/config');
   916  var SolidityParam = require('./param');
   917  
   918  
   919  /**
   920   * Formats input value to byte representation of int
   921   * If value is negative, return it's two's complement
   922   * If the value is floating point, round it down
   923   *
   924   * @method formatInputInt
   925   * @param {String|Number|BigNumber} value that needs to be formatted
   926   * @returns {SolidityParam}
   927   */
   928  var formatInputInt = function (value) {
   929      BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE);
   930      var result = utils.padLeft(utils.toTwosComplement(value).toString(16), 64);
   931      return new SolidityParam(result);
   932  };
   933  
   934  /**
   935   * Formats input bytes
   936   *
   937   * @method formatInputBytes
   938   * @param {String}
   939   * @returns {SolidityParam}
   940   */
   941  var formatInputBytes = function (value) {
   942      var result = utils.toHex(value).substr(2);
   943      var l = Math.floor((result.length + 63) / 64);
   944      result = utils.padRight(result, l * 64);
   945      return new SolidityParam(result);
   946  };
   947  
   948  /**
   949   * Formats input bytes
   950   *
   951   * @method formatDynamicInputBytes
   952   * @param {String}
   953   * @returns {SolidityParam}
   954   */
   955  var formatInputDynamicBytes = function (value) {
   956      var result = utils.toHex(value).substr(2);
   957      var length = result.length / 2;
   958      var l = Math.floor((result.length + 63) / 64);
   959      result = utils.padRight(result, l * 64);
   960      return new SolidityParam(formatInputInt(length).value + result);
   961  };
   962  
   963  /**
   964   * Formats input value to byte representation of string
   965   *
   966   * @method formatInputString
   967   * @param {String}
   968   * @returns {SolidityParam}
   969   */
   970  var formatInputString = function (value) {
   971      var result = utils.fromUtf8(value).substr(2);
   972      var length = result.length / 2;
   973      var l = Math.floor((result.length + 63) / 64);
   974      result = utils.padRight(result, l * 64);
   975      return new SolidityParam(formatInputInt(length).value + result);
   976  };
   977  
   978  /**
   979   * Formats input value to byte representation of bool
   980   *
   981   * @method formatInputBool
   982   * @param {Boolean}
   983   * @returns {SolidityParam}
   984   */
   985  var formatInputBool = function (value) {
   986      var result = '000000000000000000000000000000000000000000000000000000000000000' + (value ?  '1' : '0');
   987      return new SolidityParam(result);
   988  };
   989  
   990  /**
   991   * Formats input value to byte representation of real
   992   * Values are multiplied by 2^m and encoded as integers
   993   *
   994   * @method formatInputReal
   995   * @param {String|Number|BigNumber}
   996   * @returns {SolidityParam}
   997   */
   998  var formatInputReal = function (value) {
   999      return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128)));
  1000  };
  1001  
  1002  /**
  1003   * Check if input value is negative
  1004   *
  1005   * @method signedIsNegative
  1006   * @param {String} value is hex format
  1007   * @returns {Boolean} true if it is negative, otherwise false
  1008   */
  1009  var signedIsNegative = function (value) {
  1010      return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1';
  1011  };
  1012  
  1013  /**
  1014   * Formats right-aligned output bytes to int
  1015   *
  1016   * @method formatOutputInt
  1017   * @param {SolidityParam} param
  1018   * @returns {BigNumber} right-aligned output bytes formatted to big number
  1019   */
  1020  var formatOutputInt = function (param) {
  1021      var value = param.staticPart() || "0";
  1022  
  1023      // check if it's negative number
  1024      // it is, return two's complement
  1025      if (signedIsNegative(value)) {
  1026          return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1);
  1027      }
  1028      return new BigNumber(value, 16);
  1029  };
  1030  
  1031  /**
  1032   * Formats right-aligned output bytes to uint
  1033   *
  1034   * @method formatOutputUInt
  1035   * @param {SolidityParam}
  1036   * @returns {BigNumeber} right-aligned output bytes formatted to uint
  1037   */
  1038  var formatOutputUInt = function (param) {
  1039      var value = param.staticPart() || "0";
  1040      return new BigNumber(value, 16);
  1041  };
  1042  
  1043  /**
  1044   * Formats right-aligned output bytes to real
  1045   *
  1046   * @method formatOutputReal
  1047   * @param {SolidityParam}
  1048   * @returns {BigNumber} input bytes formatted to real
  1049   */
  1050  var formatOutputReal = function (param) {
  1051      return formatOutputInt(param).dividedBy(new BigNumber(2).pow(128));
  1052  };
  1053  
  1054  /**
  1055   * Formats right-aligned output bytes to ureal
  1056   *
  1057   * @method formatOutputUReal
  1058   * @param {SolidityParam}
  1059   * @returns {BigNumber} input bytes formatted to ureal
  1060   */
  1061  var formatOutputUReal = function (param) {
  1062      return formatOutputUInt(param).dividedBy(new BigNumber(2).pow(128));
  1063  };
  1064  
  1065  /**
  1066   * Should be used to format output bool
  1067   *
  1068   * @method formatOutputBool
  1069   * @param {SolidityParam}
  1070   * @returns {Boolean} right-aligned input bytes formatted to bool
  1071   */
  1072  var formatOutputBool = function (param) {
  1073      return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
  1074  };
  1075  
  1076  /**
  1077   * Should be used to format output bytes
  1078   *
  1079   * @method formatOutputBytes
  1080   * @param {SolidityParam} left-aligned hex representation of string
  1081   * @param {String} name type name
  1082   * @returns {String} hex string
  1083   */
  1084  var formatOutputBytes = function (param, name) {
  1085      var matches = name.match(/^bytes([0-9]*)/);
  1086      var size = parseInt(matches[1]);
  1087      return '0x' + param.staticPart().slice(0, 2 * size);
  1088  };
  1089  
  1090  /**
  1091   * Should be used to format output bytes
  1092   *
  1093   * @method formatOutputDynamicBytes
  1094   * @param {SolidityParam} left-aligned hex representation of string
  1095   * @returns {String} hex string
  1096   */
  1097  var formatOutputDynamicBytes = function (param) {
  1098      var length = (new BigNumber(param.dynamicPart().slice(0, 64), 16)).toNumber() * 2;
  1099      return '0x' + param.dynamicPart().substr(64, length);
  1100  };
  1101  
  1102  /**
  1103   * Should be used to format output string
  1104   *
  1105   * @method formatOutputString
  1106   * @param {SolidityParam} left-aligned hex representation of string
  1107   * @returns {String} ascii string
  1108   */
  1109  var formatOutputString = function (param) {
  1110      var length = (new BigNumber(param.dynamicPart().slice(0, 64), 16)).toNumber() * 2;
  1111      return utils.toUtf8(param.dynamicPart().substr(64, length));
  1112  };
  1113  
  1114  /**
  1115   * Should be used to format output address
  1116   *
  1117   * @method formatOutputAddress
  1118   * @param {SolidityParam} right-aligned input bytes
  1119   * @returns {String} address
  1120   */
  1121  var formatOutputAddress = function (param) {
  1122      var value = param.staticPart();
  1123      return "0x" + value.slice(value.length - 40, value.length);
  1124  };
  1125  
  1126  module.exports = {
  1127      formatInputInt: formatInputInt,
  1128      formatInputBytes: formatInputBytes,
  1129      formatInputDynamicBytes: formatInputDynamicBytes,
  1130      formatInputString: formatInputString,
  1131      formatInputBool: formatInputBool,
  1132      formatInputReal: formatInputReal,
  1133      formatOutputInt: formatOutputInt,
  1134      formatOutputUInt: formatOutputUInt,
  1135      formatOutputReal: formatOutputReal,
  1136      formatOutputUReal: formatOutputUReal,
  1137      formatOutputBool: formatOutputBool,
  1138      formatOutputBytes: formatOutputBytes,
  1139      formatOutputDynamicBytes: formatOutputDynamicBytes,
  1140      formatOutputString: formatOutputString,
  1141      formatOutputAddress: formatOutputAddress
  1142  };
  1143  
  1144  },{"../utils/config":18,"../utils/utils":20,"./param":11,"bignumber.js":"bignumber.js"}],10:[function(require,module,exports){
  1145  var f = require('./formatters');
  1146  var SolidityType = require('./type');
  1147  
  1148  /**
  1149   * SolidityTypeInt is a prootype that represents int type
  1150   * It matches:
  1151   * int
  1152   * int[]
  1153   * int[4]
  1154   * int[][]
  1155   * int[3][]
  1156   * int[][6][], ...
  1157   * int32
  1158   * int64[]
  1159   * int8[4]
  1160   * int256[][]
  1161   * int[3][]
  1162   * int64[][6][], ...
  1163   */
  1164  var SolidityTypeInt = function () {
  1165      this._inputFormatter = f.formatInputInt;
  1166      this._outputFormatter = f.formatOutputInt;
  1167  };
  1168  
  1169  SolidityTypeInt.prototype = new SolidityType({});
  1170  SolidityTypeInt.prototype.constructor = SolidityTypeInt;
  1171  
  1172  SolidityTypeInt.prototype.isType = function (name) {
  1173      return !!name.match(/^int([0-9]*)?(\[([0-9]*)\])*$/);
  1174  };
  1175  
  1176  module.exports = SolidityTypeInt;
  1177  
  1178  },{"./formatters":9,"./type":14}],11:[function(require,module,exports){
  1179  /*
  1180      This file is part of web3.js.
  1181  
  1182      web3.js is free software: you can redistribute it and/or modify
  1183      it under the terms of the GNU Lesser General Public License as published by
  1184      the Free Software Foundation, either version 3 of the License, or
  1185      (at your option) any later version.
  1186  
  1187      web3.js is distributed in the hope that it will be useful,
  1188      but WITHOUT ANY WARRANTY; without even the implied warranty of
  1189      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1190      GNU Lesser General Public License for more details.
  1191  
  1192      You should have received a copy of the GNU Lesser General Public License
  1193      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  1194  */
  1195  /**
  1196   * @file param.js
  1197   * @author Marek Kotewicz <marek@ethdev.com>
  1198   * @date 2015
  1199   */
  1200  
  1201  var utils = require('../utils/utils');
  1202  
  1203  /**
  1204   * SolidityParam object prototype.
  1205   * Should be used when encoding, decoding solidity bytes
  1206   */
  1207  var SolidityParam = function (value, offset) {
  1208      this.value = value || '';
  1209      this.offset = offset; // offset in bytes
  1210  };
  1211  
  1212  /**
  1213   * This method should be used to get length of params's dynamic part
  1214   *
  1215   * @method dynamicPartLength
  1216   * @returns {Number} length of dynamic part (in bytes)
  1217   */
  1218  SolidityParam.prototype.dynamicPartLength = function () {
  1219      return this.dynamicPart().length / 2;
  1220  };
  1221  
  1222  /**
  1223   * This method should be used to create copy of solidity param with different offset
  1224   *
  1225   * @method withOffset
  1226   * @param {Number} offset length in bytes
  1227   * @returns {SolidityParam} new solidity param with applied offset
  1228   */
  1229  SolidityParam.prototype.withOffset = function (offset) {
  1230      return new SolidityParam(this.value, offset);
  1231  };
  1232  
  1233  /**
  1234   * This method should be used to combine solidity params together
  1235   * eg. when appending an array
  1236   *
  1237   * @method combine
  1238   * @param {SolidityParam} param with which we should combine
  1239   * @param {SolidityParam} result of combination
  1240   */
  1241  SolidityParam.prototype.combine = function (param) {
  1242      return new SolidityParam(this.value + param.value);
  1243  };
  1244  
  1245  /**
  1246   * This method should be called to check if param has dynamic size.
  1247   * If it has, it returns true, otherwise false
  1248   *
  1249   * @method isDynamic
  1250   * @returns {Boolean}
  1251   */
  1252  SolidityParam.prototype.isDynamic = function () {
  1253      return this.offset !== undefined;
  1254  };
  1255  
  1256  /**
  1257   * This method should be called to transform offset to bytes
  1258   *
  1259   * @method offsetAsBytes
  1260   * @returns {String} bytes representation of offset
  1261   */
  1262  SolidityParam.prototype.offsetAsBytes = function () {
  1263      return !this.isDynamic() ? '' : utils.padLeft(utils.toTwosComplement(this.offset).toString(16), 64);
  1264  };
  1265  
  1266  /**
  1267   * This method should be called to get static part of param
  1268   *
  1269   * @method staticPart
  1270   * @returns {String} offset if it is a dynamic param, otherwise value
  1271   */
  1272  SolidityParam.prototype.staticPart = function () {
  1273      if (!this.isDynamic()) {
  1274          return this.value;
  1275      }
  1276      return this.offsetAsBytes();
  1277  };
  1278  
  1279  /**
  1280   * This method should be called to get dynamic part of param
  1281   *
  1282   * @method dynamicPart
  1283   * @returns {String} returns a value if it is a dynamic param, otherwise empty string
  1284   */
  1285  SolidityParam.prototype.dynamicPart = function () {
  1286      return this.isDynamic() ? this.value : '';
  1287  };
  1288  
  1289  /**
  1290   * This method should be called to encode param
  1291   *
  1292   * @method encode
  1293   * @returns {String}
  1294   */
  1295  SolidityParam.prototype.encode = function () {
  1296      return this.staticPart() + this.dynamicPart();
  1297  };
  1298  
  1299  /**
  1300   * This method should be called to encode array of params
  1301   *
  1302   * @method encodeList
  1303   * @param {Array[SolidityParam]} params
  1304   * @returns {String}
  1305   */
  1306  SolidityParam.encodeList = function (params) {
  1307  
  1308      // updating offsets
  1309      var totalOffset = params.length * 32;
  1310      var offsetParams = params.map(function (param) {
  1311          if (!param.isDynamic()) {
  1312              return param;
  1313          }
  1314          var offset = totalOffset;
  1315          totalOffset += param.dynamicPartLength();
  1316          return param.withOffset(offset);
  1317      });
  1318  
  1319      // encode everything!
  1320      return offsetParams.reduce(function (result, param) {
  1321          return result + param.dynamicPart();
  1322      }, offsetParams.reduce(function (result, param) {
  1323          return result + param.staticPart();
  1324      }, ''));
  1325  };
  1326  
  1327  
  1328  
  1329  module.exports = SolidityParam;
  1330  
  1331  
  1332  },{"../utils/utils":20}],12:[function(require,module,exports){
  1333  var f = require('./formatters');
  1334  var SolidityType = require('./type');
  1335  
  1336  /**
  1337   * SolidityTypeReal is a prootype that represents real type
  1338   * It matches:
  1339   * real
  1340   * real[]
  1341   * real[4]
  1342   * real[][]
  1343   * real[3][]
  1344   * real[][6][], ...
  1345   * real32
  1346   * real64[]
  1347   * real8[4]
  1348   * real256[][]
  1349   * real[3][]
  1350   * real64[][6][], ...
  1351   */
  1352  var SolidityTypeReal = function () {
  1353      this._inputFormatter = f.formatInputReal;
  1354      this._outputFormatter = f.formatOutputReal;
  1355  };
  1356  
  1357  SolidityTypeReal.prototype = new SolidityType({});
  1358  SolidityTypeReal.prototype.constructor = SolidityTypeReal;
  1359  
  1360  SolidityTypeReal.prototype.isType = function (name) {
  1361      return !!name.match(/real([0-9]*)?(\[([0-9]*)\])?/);
  1362  };
  1363  
  1364  module.exports = SolidityTypeReal;
  1365  
  1366  },{"./formatters":9,"./type":14}],13:[function(require,module,exports){
  1367  var f = require('./formatters');
  1368  var SolidityType = require('./type');
  1369  
  1370  var SolidityTypeString = function () {
  1371      this._inputFormatter = f.formatInputString;
  1372      this._outputFormatter = f.formatOutputString;
  1373  };
  1374  
  1375  SolidityTypeString.prototype = new SolidityType({});
  1376  SolidityTypeString.prototype.constructor = SolidityTypeString;
  1377  
  1378  SolidityTypeString.prototype.isType = function (name) {
  1379      return !!name.match(/^string(\[([0-9]*)\])*$/);
  1380  };
  1381  
  1382  SolidityTypeString.prototype.isDynamicType = function () {
  1383      return true;
  1384  };
  1385  
  1386  module.exports = SolidityTypeString;
  1387  
  1388  },{"./formatters":9,"./type":14}],14:[function(require,module,exports){
  1389  var f = require('./formatters');
  1390  var SolidityParam = require('./param');
  1391  
  1392  /**
  1393   * SolidityType prototype is used to encode/decode solidity params of certain type
  1394   */
  1395  var SolidityType = function (config) {
  1396      this._inputFormatter = config.inputFormatter;
  1397      this._outputFormatter = config.outputFormatter;
  1398  };
  1399  
  1400  /**
  1401   * Should be used to determine if this SolidityType do match given name
  1402   *
  1403   * @method isType
  1404   * @param {String} name
  1405   * @return {Bool} true if type match this SolidityType, otherwise false
  1406   */
  1407  SolidityType.prototype.isType = function (name) {
  1408      throw "this method should be overrwritten for type " + name;
  1409  };
  1410  
  1411  /**
  1412   * Should be used to determine what is the length of static part in given type
  1413   *
  1414   * @method staticPartLength
  1415   * @param {String} name
  1416   * @return {Number} length of static part in bytes
  1417   */
  1418  SolidityType.prototype.staticPartLength = function (name) {
  1419      // If name isn't an array then treat it like a single element array.
  1420      return (this.nestedTypes(name) || ['[1]'])
  1421          .map(function (type) {
  1422              // the length of the nested array
  1423              return parseInt(type.slice(1, -1), 10) || 1;
  1424          })
  1425          .reduce(function (previous, current) {
  1426              return previous * current;
  1427          // all basic types are 32 bytes long
  1428          }, 32);
  1429  };
  1430  
  1431  /**
  1432   * Should be used to determine if type is dynamic array
  1433   * eg:
  1434   * "type[]" => true
  1435   * "type[4]" => false
  1436   *
  1437   * @method isDynamicArray
  1438   * @param {String} name
  1439   * @return {Bool} true if the type is dynamic array
  1440   */
  1441  SolidityType.prototype.isDynamicArray = function (name) {
  1442      var nestedTypes = this.nestedTypes(name);
  1443      return !!nestedTypes && !nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g);
  1444  };
  1445  
  1446  /**
  1447   * Should be used to determine if type is static array
  1448   * eg:
  1449   * "type[]" => false
  1450   * "type[4]" => true
  1451   *
  1452   * @method isStaticArray
  1453   * @param {String} name
  1454   * @return {Bool} true if the type is static array
  1455   */
  1456  SolidityType.prototype.isStaticArray = function (name) {
  1457      var nestedTypes = this.nestedTypes(name);
  1458      return !!nestedTypes && !!nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g);
  1459  };
  1460  
  1461  /**
  1462   * Should return length of static array
  1463   * eg.
  1464   * "int[32]" => 32
  1465   * "int256[14]" => 14
  1466   * "int[2][3]" => 3
  1467   * "int" => 1
  1468   * "int[1]" => 1
  1469   * "int[]" => 1
  1470   *
  1471   * @method staticArrayLength
  1472   * @param {String} name
  1473   * @return {Number} static array length
  1474   */
  1475  SolidityType.prototype.staticArrayLength = function (name) {
  1476      var nestedTypes = this.nestedTypes(name);
  1477      if (nestedTypes) {
  1478         return parseInt(nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g) || 1);
  1479      }
  1480      return 1;
  1481  };
  1482  
  1483  /**
  1484   * Should return nested type
  1485   * eg.
  1486   * "int[32]" => "int"
  1487   * "int256[14]" => "int256"
  1488   * "int[2][3]" => "int[2]"
  1489   * "int" => "int"
  1490   * "int[]" => "int"
  1491   *
  1492   * @method nestedName
  1493   * @param {String} name
  1494   * @return {String} nested name
  1495   */
  1496  SolidityType.prototype.nestedName = function (name) {
  1497      // remove last [] in name
  1498      var nestedTypes = this.nestedTypes(name);
  1499      if (!nestedTypes) {
  1500          return name;
  1501      }
  1502  
  1503      return name.substr(0, name.length - nestedTypes[nestedTypes.length - 1].length);
  1504  };
  1505  
  1506  /**
  1507   * Should return true if type has dynamic size by default
  1508   * such types are "string", "bytes"
  1509   *
  1510   * @method isDynamicType
  1511   * @param {String} name
  1512   * @return {Bool} true if is dynamic, otherwise false
  1513   */
  1514  SolidityType.prototype.isDynamicType = function () {
  1515      return false;
  1516  };
  1517  
  1518  /**
  1519   * Should return array of nested types
  1520   * eg.
  1521   * "int[2][3][]" => ["[2]", "[3]", "[]"]
  1522   * "int[] => ["[]"]
  1523   * "int" => null
  1524   *
  1525   * @method nestedTypes
  1526   * @param {String} name
  1527   * @return {Array} array of nested types
  1528   */
  1529  SolidityType.prototype.nestedTypes = function (name) {
  1530      // return list of strings eg. "[]", "[3]", "[]", "[2]"
  1531      return name.match(/(\[[0-9]*\])/g);
  1532  };
  1533  
  1534  /**
  1535   * Should be used to encode the value
  1536   *
  1537   * @method encode
  1538   * @param {Object} value
  1539   * @param {String} name
  1540   * @return {String} encoded value
  1541   */
  1542  SolidityType.prototype.encode = function (value, name) {
  1543      var self = this;
  1544      if (this.isDynamicArray(name)) {
  1545  
  1546          return (function () {
  1547              var length = value.length;                          // in int
  1548              var nestedName = self.nestedName(name);
  1549  
  1550              var result = [];
  1551              result.push(f.formatInputInt(length).encode());
  1552  
  1553              value.forEach(function (v) {
  1554                  result.push(self.encode(v, nestedName));
  1555              });
  1556  
  1557              return result;
  1558          })();
  1559  
  1560      } else if (this.isStaticArray(name)) {
  1561  
  1562          return (function () {
  1563              var length = self.staticArrayLength(name);          // in int
  1564              var nestedName = self.nestedName(name);
  1565  
  1566              var result = [];
  1567              for (var i = 0; i < length; i++) {
  1568                  result.push(self.encode(value[i], nestedName));
  1569              }
  1570  
  1571              return result;
  1572          })();
  1573  
  1574      }
  1575  
  1576      return this._inputFormatter(value, name).encode();
  1577  };
  1578  
  1579  /**
  1580   * Should be used to decode value from bytes
  1581   *
  1582   * @method decode
  1583   * @param {String} bytes
  1584   * @param {Number} offset in bytes
  1585   * @param {String} name type name
  1586   * @returns {Object} decoded value
  1587   */
  1588  SolidityType.prototype.decode = function (bytes, offset, name) {
  1589      var self = this;
  1590  
  1591      if (this.isDynamicArray(name)) {
  1592  
  1593          return (function () {
  1594              var arrayOffset = parseInt('0x' + bytes.substr(offset * 2, 64)); // in bytes
  1595              var length = parseInt('0x' + bytes.substr(arrayOffset * 2, 64)); // in int
  1596              var arrayStart = arrayOffset + 32; // array starts after length; // in bytes
  1597  
  1598              var nestedName = self.nestedName(name);
  1599              var nestedStaticPartLength = self.staticPartLength(nestedName);  // in bytes
  1600              var roundedNestedStaticPartLength = Math.floor((nestedStaticPartLength + 31) / 32) * 32;
  1601              var result = [];
  1602  
  1603              for (var i = 0; i < length * roundedNestedStaticPartLength; i += roundedNestedStaticPartLength) {
  1604                  result.push(self.decode(bytes, arrayStart + i, nestedName));
  1605              }
  1606  
  1607              return result;
  1608          })();
  1609  
  1610      } else if (this.isStaticArray(name)) {
  1611  
  1612          return (function () {
  1613              var length = self.staticArrayLength(name);                      // in int
  1614              var arrayStart = offset;                                        // in bytes
  1615  
  1616              var nestedName = self.nestedName(name);
  1617              var nestedStaticPartLength = self.staticPartLength(nestedName); // in bytes
  1618              var roundedNestedStaticPartLength = Math.floor((nestedStaticPartLength + 31) / 32) * 32;
  1619              var result = [];
  1620  
  1621              for (var i = 0; i < length * roundedNestedStaticPartLength; i += roundedNestedStaticPartLength) {
  1622                  result.push(self.decode(bytes, arrayStart + i, nestedName));
  1623              }
  1624  
  1625              return result;
  1626          })();
  1627      } else if (this.isDynamicType(name)) {
  1628  
  1629          return (function () {
  1630              var dynamicOffset = parseInt('0x' + bytes.substr(offset * 2, 64));      // in bytes
  1631              var length = parseInt('0x' + bytes.substr(dynamicOffset * 2, 64));      // in bytes
  1632              var roundedLength = Math.floor((length + 31) / 32);                     // in int
  1633              var param = new SolidityParam(bytes.substr(dynamicOffset * 2, ( 1 + roundedLength) * 64), 0);
  1634              return self._outputFormatter(param, name);
  1635          })();
  1636      }
  1637  
  1638      var length = this.staticPartLength(name);
  1639      var param = new SolidityParam(bytes.substr(offset * 2, length * 2));
  1640      return this._outputFormatter(param, name);
  1641  };
  1642  
  1643  module.exports = SolidityType;
  1644  
  1645  },{"./formatters":9,"./param":11}],15:[function(require,module,exports){
  1646  var f = require('./formatters');
  1647  var SolidityType = require('./type');
  1648  
  1649  /**
  1650   * SolidityTypeUInt is a prootype that represents uint type
  1651   * It matches:
  1652   * uint
  1653   * uint[]
  1654   * uint[4]
  1655   * uint[][]
  1656   * uint[3][]
  1657   * uint[][6][], ...
  1658   * uint32
  1659   * uint64[]
  1660   * uint8[4]
  1661   * uint256[][]
  1662   * uint[3][]
  1663   * uint64[][6][], ...
  1664   */
  1665  var SolidityTypeUInt = function () {
  1666      this._inputFormatter = f.formatInputInt;
  1667      this._outputFormatter = f.formatOutputUInt;
  1668  };
  1669  
  1670  SolidityTypeUInt.prototype = new SolidityType({});
  1671  SolidityTypeUInt.prototype.constructor = SolidityTypeUInt;
  1672  
  1673  SolidityTypeUInt.prototype.isType = function (name) {
  1674      return !!name.match(/^uint([0-9]*)?(\[([0-9]*)\])*$/);
  1675  };
  1676  
  1677  module.exports = SolidityTypeUInt;
  1678  
  1679  },{"./formatters":9,"./type":14}],16:[function(require,module,exports){
  1680  var f = require('./formatters');
  1681  var SolidityType = require('./type');
  1682  
  1683  /**
  1684   * SolidityTypeUReal is a prootype that represents ureal type
  1685   * It matches:
  1686   * ureal
  1687   * ureal[]
  1688   * ureal[4]
  1689   * ureal[][]
  1690   * ureal[3][]
  1691   * ureal[][6][], ...
  1692   * ureal32
  1693   * ureal64[]
  1694   * ureal8[4]
  1695   * ureal256[][]
  1696   * ureal[3][]
  1697   * ureal64[][6][], ...
  1698   */
  1699  var SolidityTypeUReal = function () {
  1700      this._inputFormatter = f.formatInputReal;
  1701      this._outputFormatter = f.formatOutputUReal;
  1702  };
  1703  
  1704  SolidityTypeUReal.prototype = new SolidityType({});
  1705  SolidityTypeUReal.prototype.constructor = SolidityTypeUReal;
  1706  
  1707  SolidityTypeUReal.prototype.isType = function (name) {
  1708      return !!name.match(/^ureal([0-9]*)?(\[([0-9]*)\])*$/);
  1709  };
  1710  
  1711  module.exports = SolidityTypeUReal;
  1712  
  1713  },{"./formatters":9,"./type":14}],17:[function(require,module,exports){
  1714  'use strict';
  1715  
  1716  // go env doesn't have and need XMLHttpRequest
  1717  if (typeof XMLHttpRequest === 'undefined') {
  1718      exports.XMLHttpRequest = {};
  1719  } else {
  1720      exports.XMLHttpRequest = XMLHttpRequest; // jshint ignore:line
  1721  }
  1722  
  1723  
  1724  },{}],18:[function(require,module,exports){
  1725  /*
  1726      This file is part of web3.js.
  1727  
  1728      web3.js is free software: you can redistribute it and/or modify
  1729      it under the terms of the GNU Lesser General Public License as published by
  1730      the Free Software Foundation, either version 3 of the License, or
  1731      (at your option) any later version.
  1732  
  1733      web3.js is distributed in the hope that it will be useful,
  1734      but WITHOUT ANY WARRANTY; without even the implied warranty of
  1735      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1736      GNU Lesser General Public License for more details.
  1737  
  1738      You should have received a copy of the GNU Lesser General Public License
  1739      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  1740  */
  1741  /** @file config.js
  1742   * @authors:
  1743   *   Marek Kotewicz <marek@ethdev.com>
  1744   * @date 2015
  1745   */
  1746  
  1747  /**
  1748   * Utils
  1749   *
  1750   * @module utils
  1751   */
  1752  
  1753  /**
  1754   * Utility functions
  1755   *
  1756   * @class [utils] config
  1757   * @constructor
  1758   */
  1759  
  1760  
  1761  /// required to define ETH_BIGNUMBER_ROUNDING_MODE
  1762  var BigNumber = require('bignumber.js');
  1763  
  1764  var ETH_UNITS = [
  1765      'wei',
  1766      'kwei',
  1767      'Mwei',
  1768      'Gwei',
  1769      'szabo',
  1770      'finney',
  1771      'femtoether',
  1772      'picoether',
  1773      'nanoether',
  1774      'microether',
  1775      'milliether',
  1776      'nano',
  1777      'micro',
  1778      'milli',
  1779      'ether',
  1780      'grand',
  1781      'Mether',
  1782      'Gether',
  1783      'Tether',
  1784      'Pether',
  1785      'Eether',
  1786      'Zether',
  1787      'Yether',
  1788      'Nether',
  1789      'Dether',
  1790      'Vether',
  1791      'Uether'
  1792  ];
  1793  
  1794  module.exports = {
  1795      ETH_PADDING: 32,
  1796      ETH_SIGNATURE_LENGTH: 4,
  1797      ETH_UNITS: ETH_UNITS,
  1798      ETH_BIGNUMBER_ROUNDING_MODE: { ROUNDING_MODE: BigNumber.ROUND_DOWN },
  1799      ETH_POLLING_TIMEOUT: 1000/2,
  1800      defaultBlock: 'latest',
  1801      defaultAccount: undefined
  1802  };
  1803  
  1804  
  1805  },{"bignumber.js":"bignumber.js"}],19:[function(require,module,exports){
  1806  /*
  1807      This file is part of web3.js.
  1808  
  1809      web3.js is free software: you can redistribute it and/or modify
  1810      it under the terms of the GNU Lesser General Public License as published by
  1811      the Free Software Foundation, either version 3 of the License, or
  1812      (at your option) any later version.
  1813  
  1814      web3.js is distributed in the hope that it will be useful,
  1815      but WITHOUT ANY WARRANTY; without even the implied warranty of
  1816      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1817      GNU Lesser General Public License for more details.
  1818  
  1819      You should have received a copy of the GNU Lesser General Public License
  1820      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  1821  */
  1822  /**
  1823   * @file sha3.js
  1824   * @author Marek Kotewicz <marek@ethdev.com>
  1825   * @date 2015
  1826   */
  1827  
  1828  var CryptoJS = require('crypto-js');
  1829  var sha3 = require('crypto-js/sha3');
  1830  
  1831  module.exports = function (value, options) {
  1832      if (options && options.encoding === 'hex') {
  1833          if (value.length > 2 && value.substr(0, 2) === '0x') {
  1834              value = value.substr(2);
  1835          }
  1836          value = CryptoJS.enc.Hex.parse(value);
  1837      }
  1838  
  1839      return sha3(value, {
  1840          outputLength: 256
  1841      }).toString();
  1842  };
  1843  
  1844  
  1845  },{"crypto-js":59,"crypto-js/sha3":80}],20:[function(require,module,exports){
  1846  /*
  1847      This file is part of web3.js.
  1848  
  1849      web3.js is free software: you can redistribute it and/or modify
  1850      it under the terms of the GNU Lesser General Public License as published by
  1851      the Free Software Foundation, either version 3 of the License, or
  1852      (at your option) any later version.
  1853  
  1854      web3.js is distributed in the hope that it will be useful,
  1855      but WITHOUT ANY WARRANTY; without even the implied warranty of
  1856      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1857      GNU Lesser General Public License for more details.
  1858  
  1859      You should have received a copy of the GNU Lesser General Public License
  1860      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  1861  */
  1862  /**
  1863   * @file utils.js
  1864   * @author Marek Kotewicz <marek@ethdev.com>
  1865   * @date 2015
  1866   */
  1867  
  1868  /**
  1869   * Utils
  1870   *
  1871   * @module utils
  1872   */
  1873  
  1874  /**
  1875   * Utility functions
  1876   *
  1877   * @class [utils] utils
  1878   * @constructor
  1879   */
  1880  
  1881  
  1882  var BigNumber = require('bignumber.js');
  1883  var sha3 = require('./sha3.js');
  1884  var utf8 = require('utf8');
  1885  
  1886  var unitMap = {
  1887      'noether':      '0',
  1888      'wei':          '1',
  1889      'kwei':         '1000',
  1890      'Kwei':         '1000',
  1891      'babbage':      '1000',
  1892      'femtoether':   '1000',
  1893      'mwei':         '1000000',
  1894      'Mwei':         '1000000',
  1895      'lovelace':     '1000000',
  1896      'picoether':    '1000000',
  1897      'gwei':         '1000000000',
  1898      'Gwei':         '1000000000',
  1899      'shannon':      '1000000000',
  1900      'nanoether':    '1000000000',
  1901      'nano':         '1000000000',
  1902      'szabo':        '1000000000000',
  1903      'microether':   '1000000000000',
  1904      'micro':        '1000000000000',
  1905      'finney':       '1000000000000000',
  1906      'milliether':    '1000000000000000',
  1907      'milli':         '1000000000000000',
  1908      'ether':        '1000000000000000000',
  1909      'kether':       '1000000000000000000000',
  1910      'grand':        '1000000000000000000000',
  1911      'mether':       '1000000000000000000000000',
  1912      'gether':       '1000000000000000000000000000',
  1913      'tether':       '1000000000000000000000000000000'
  1914  };
  1915  
  1916  /**
  1917   * Should be called to pad string to expected length
  1918   *
  1919   * @method padLeft
  1920   * @param {String} string to be padded
  1921   * @param {Number} characters that result string should have
  1922   * @param {String} sign, by default 0
  1923   * @returns {String} right aligned string
  1924   */
  1925  var padLeft = function (string, chars, sign) {
  1926      return new Array(chars - string.length + 1).join(sign ? sign : "0") + string;
  1927  };
  1928  
  1929  /**
  1930   * Should be called to pad string to expected length
  1931   *
  1932   * @method padRight
  1933   * @param {String} string to be padded
  1934   * @param {Number} characters that result string should have
  1935   * @param {String} sign, by default 0
  1936   * @returns {String} right aligned string
  1937   */
  1938  var padRight = function (string, chars, sign) {
  1939      return string + (new Array(chars - string.length + 1).join(sign ? sign : "0"));
  1940  };
  1941  
  1942  /**
  1943   * Should be called to get utf8 from it's hex representation
  1944   *
  1945   * @method toUtf8
  1946   * @param {String} string in hex
  1947   * @returns {String} ascii string representation of hex value
  1948   */
  1949  var toUtf8 = function(hex) {
  1950  // Find termination
  1951      var str = "";
  1952      var i = 0, l = hex.length;
  1953      if (hex.substring(0, 2) === '0x') {
  1954          i = 2;
  1955      }
  1956      for (; i < l; i+=2) {
  1957          var code = parseInt(hex.substr(i, 2), 16);
  1958          if (code === 0)
  1959              break;
  1960          str += String.fromCharCode(code);
  1961      }
  1962  
  1963      return utf8.decode(str);
  1964  };
  1965  
  1966  /**
  1967   * Should be called to get ascii from it's hex representation
  1968   *
  1969   * @method toAscii
  1970   * @param {String} string in hex
  1971   * @returns {String} ascii string representation of hex value
  1972   */
  1973  var toAscii = function(hex) {
  1974  // Find termination
  1975      var str = "";
  1976      var i = 0, l = hex.length;
  1977      if (hex.substring(0, 2) === '0x') {
  1978          i = 2;
  1979      }
  1980      for (; i < l; i+=2) {
  1981          var code = parseInt(hex.substr(i, 2), 16);
  1982          str += String.fromCharCode(code);
  1983      }
  1984  
  1985      return str;
  1986  };
  1987  
  1988  /**
  1989   * Should be called to get hex representation (prefixed by 0x) of utf8 string
  1990   *
  1991   * @method fromUtf8
  1992   * @param {String} string
  1993   * @param {Number} optional padding
  1994   * @returns {String} hex representation of input string
  1995   */
  1996  var fromUtf8 = function(str) {
  1997      str = utf8.encode(str);
  1998      var hex = "";
  1999      for(var i = 0; i < str.length; i++) {
  2000          var code = str.charCodeAt(i);
  2001          if (code === 0)
  2002              break;
  2003          var n = code.toString(16);
  2004          hex += n.length < 2 ? '0' + n : n;
  2005      }
  2006  
  2007      return "0x" + hex;
  2008  };
  2009  
  2010  /**
  2011   * Should be called to get hex representation (prefixed by 0x) of ascii string
  2012   *
  2013   * @method fromAscii
  2014   * @param {String} string
  2015   * @param {Number} optional padding
  2016   * @returns {String} hex representation of input string
  2017   */
  2018  var fromAscii = function(str) {
  2019      var hex = "";
  2020      for(var i = 0; i < str.length; i++) {
  2021          var code = str.charCodeAt(i);
  2022          var n = code.toString(16);
  2023          hex += n.length < 2 ? '0' + n : n;
  2024      }
  2025  
  2026      return "0x" + hex;
  2027  };
  2028  
  2029  /**
  2030   * Should be used to create full function/event name from json abi
  2031   *
  2032   * @method transformToFullName
  2033   * @param {Object} json-abi
  2034   * @return {String} full fnction/event name
  2035   */
  2036  var transformToFullName = function (json) {
  2037      if (json.name.indexOf('(') !== -1) {
  2038          return json.name;
  2039      }
  2040  
  2041      var typeName = json.inputs.map(function(i){return i.type; }).join();
  2042      return json.name + '(' + typeName + ')';
  2043  };
  2044  
  2045  /**
  2046   * Should be called to get display name of contract function
  2047   *
  2048   * @method extractDisplayName
  2049   * @param {String} name of function/event
  2050   * @returns {String} display name for function/event eg. multiply(uint256) -> multiply
  2051   */
  2052  var extractDisplayName = function (name) {
  2053      var length = name.indexOf('(');
  2054      return length !== -1 ? name.substr(0, length) : name;
  2055  };
  2056  
  2057  /// @returns overloaded part of function/event name
  2058  var extractTypeName = function (name) {
  2059      /// TODO: make it invulnerable
  2060      var length = name.indexOf('(');
  2061      return length !== -1 ? name.substr(length + 1, name.length - 1 - (length + 1)).replace(' ', '') : "";
  2062  };
  2063  
  2064  /**
  2065   * Converts value to it's decimal representation in string
  2066   *
  2067   * @method toDecimal
  2068   * @param {String|Number|BigNumber}
  2069   * @return {String}
  2070   */
  2071  var toDecimal = function (value) {
  2072      return toBigNumber(value).toNumber();
  2073  };
  2074  
  2075  /**
  2076   * Converts value to it's hex representation
  2077   *
  2078   * @method fromDecimal
  2079   * @param {String|Number|BigNumber}
  2080   * @return {String}
  2081   */
  2082  var fromDecimal = function (value) {
  2083      var number = toBigNumber(value);
  2084      var result = number.toString(16);
  2085  
  2086      return number.lessThan(0) ? '-0x' + result.substr(1) : '0x' + result;
  2087  };
  2088  
  2089  /**
  2090   * Auto converts any given value into it's hex representation.
  2091   *
  2092   * And even stringifys objects before.
  2093   *
  2094   * @method toHex
  2095   * @param {String|Number|BigNumber|Object}
  2096   * @return {String}
  2097   */
  2098  var toHex = function (val) {
  2099      /*jshint maxcomplexity: 8 */
  2100  
  2101      if (isBoolean(val))
  2102          return fromDecimal(+val);
  2103  
  2104      if (isBigNumber(val))
  2105          return fromDecimal(val);
  2106  
  2107      if (typeof val === 'object')
  2108          return fromUtf8(JSON.stringify(val));
  2109  
  2110      // if its a negative number, pass it through fromDecimal
  2111      if (isString(val)) {
  2112          if (val.indexOf('-0x') === 0)
  2113              return fromDecimal(val);
  2114          else if(val.indexOf('0x') === 0)
  2115              return val;
  2116          else if (!isFinite(val))
  2117              return fromAscii(val);
  2118      }
  2119  
  2120      return fromDecimal(val);
  2121  };
  2122  
  2123  /**
  2124   * Returns value of unit in Wei
  2125   *
  2126   * @method getValueOfUnit
  2127   * @param {String} unit the unit to convert to, default ether
  2128   * @returns {BigNumber} value of the unit (in Wei)
  2129   * @throws error if the unit is not correct:w
  2130   */
  2131  var getValueOfUnit = function (unit) {
  2132      unit = unit ? unit.toLowerCase() : 'ether';
  2133      var unitValue = unitMap[unit];
  2134      if (unitValue === undefined) {
  2135          throw new Error('This unit doesn\'t exists, please use the one of the following units' + JSON.stringify(unitMap, null, 2));
  2136      }
  2137      return new BigNumber(unitValue, 10);
  2138  };
  2139  
  2140  /**
  2141   * Takes a number of wei and converts it to any other ether unit.
  2142   *
  2143   * Possible units are:
  2144   *   SI Short   SI Full        Effigy       Other
  2145   * - kwei       femtoether     babbage
  2146   * - mwei       picoether      lovelace
  2147   * - gwei       nanoether      shannon      nano
  2148   * - --         microether     szabo        micro
  2149   * - --         milliether     finney       milli
  2150   * - ether      --             --
  2151   * - kether                    --           grand
  2152   * - mether
  2153   * - gether
  2154   * - tether
  2155   *
  2156   * @method fromWei
  2157   * @param {Number|String} number can be a number, number string or a HEX of a decimal
  2158   * @param {String} unit the unit to convert to, default ether
  2159   * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number
  2160  */
  2161  var fromWei = function(number, unit) {
  2162      var returnValue = toBigNumber(number).dividedBy(getValueOfUnit(unit));
  2163  
  2164      return isBigNumber(number) ? returnValue : returnValue.toString(10);
  2165  };
  2166  
  2167  /**
  2168   * Takes a number of a unit and converts it to wei.
  2169   *
  2170   * Possible units are:
  2171   *   SI Short   SI Full        Effigy       Other
  2172   * - kwei       femtoether     babbage
  2173   * - mwei       picoether      lovelace
  2174   * - gwei       nanoether      shannon      nano
  2175   * - --         microether     szabo        micro
  2176   * - --         microether     szabo        micro
  2177   * - --         milliether     finney       milli
  2178   * - ether      --             --
  2179   * - kether                    --           grand
  2180   * - mether
  2181   * - gether
  2182   * - tether
  2183   *
  2184   * @method toWei
  2185   * @param {Number|String|BigNumber} number can be a number, number string or a HEX of a decimal
  2186   * @param {String} unit the unit to convert from, default ether
  2187   * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number
  2188  */
  2189  var toWei = function(number, unit) {
  2190      var returnValue = toBigNumber(number).times(getValueOfUnit(unit));
  2191  
  2192      return isBigNumber(number) ? returnValue : returnValue.toString(10);
  2193  };
  2194  
  2195  /**
  2196   * Takes an input and transforms it into a bignumber
  2197   *
  2198   * @method toBigNumber
  2199   * @param {Number|String|BigNumber} a number, string, HEX string or BigNumber
  2200   * @return {BigNumber} BigNumber
  2201  */
  2202  var toBigNumber = function(number) {
  2203      /*jshint maxcomplexity:5 */
  2204      number = number || 0;
  2205      if (isBigNumber(number))
  2206          return number;
  2207  
  2208      if (isString(number) && (number.indexOf('0x') === 0 || number.indexOf('-0x') === 0)) {
  2209          return new BigNumber(number.replace('0x',''), 16);
  2210      }
  2211  
  2212      return new BigNumber(number.toString(10), 10);
  2213  };
  2214  
  2215  /**
  2216   * Takes and input transforms it into bignumber and if it is negative value, into two's complement
  2217   *
  2218   * @method toTwosComplement
  2219   * @param {Number|String|BigNumber}
  2220   * @return {BigNumber}
  2221   */
  2222  var toTwosComplement = function (number) {
  2223      var bigNumber = toBigNumber(number).round();
  2224      if (bigNumber.lessThan(0)) {
  2225          return new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(bigNumber).plus(1);
  2226      }
  2227      return bigNumber;
  2228  };
  2229  
  2230  /**
  2231   * Checks if the given string is strictly an address
  2232   *
  2233   * @method isStrictAddress
  2234   * @param {String} address the given HEX address
  2235   * @return {Boolean}
  2236  */
  2237  var isStrictAddress = function (address) {
  2238      return /^0x[0-9a-f]{40}$/i.test(address);
  2239  };
  2240  
  2241  /**
  2242   * Checks if the given string is an address
  2243   *
  2244   * @method isAddress
  2245   * @param {String} address the given HEX address
  2246   * @return {Boolean}
  2247  */
  2248  var isAddress = function (address) {
  2249      if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
  2250          // check if it has the basic requirements of an address
  2251          return false;
  2252      } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
  2253          // If it's all small caps or all caps, return true
  2254          return true;
  2255      } else {
  2256          // Otherwise check each case
  2257          return isChecksumAddress(address);
  2258      }
  2259  };
  2260  
  2261  /**
  2262   * Checks if the given string is a checksummed address
  2263   *
  2264   * @method isChecksumAddress
  2265   * @param {String} address the given HEX address
  2266   * @return {Boolean}
  2267  */
  2268  var isChecksumAddress = function (address) {
  2269      // Check each case
  2270      address = address.replace('0x','');
  2271      var addressHash = sha3(address.toLowerCase());
  2272  
  2273      for (var i = 0; i < 40; i++ ) {
  2274          // the nth letter should be uppercase if the nth digit of casemap is 1
  2275          if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) || (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) {
  2276              return false;
  2277          }
  2278      }
  2279      return true;
  2280  };
  2281  
  2282  
  2283  
  2284  /**
  2285   * Makes a checksum address
  2286   *
  2287   * @method toChecksumAddress
  2288   * @param {String} address the given HEX address
  2289   * @return {String}
  2290  */
  2291  var toChecksumAddress = function (address) {
  2292      if (typeof address === 'undefined') return '';
  2293  
  2294      address = address.toLowerCase().replace('0x','');
  2295      var addressHash = sha3(address);
  2296      var checksumAddress = '0x';
  2297  
  2298      for (var i = 0; i < address.length; i++ ) {
  2299          // If ith character is 9 to f then make it uppercase
  2300          if (parseInt(addressHash[i], 16) > 7) {
  2301            checksumAddress += address[i].toUpperCase();
  2302          } else {
  2303              checksumAddress += address[i];
  2304          }
  2305      }
  2306      return checksumAddress;
  2307  };
  2308  
  2309  /**
  2310   * Transforms given string to valid 20 bytes-length addres with 0x prefix
  2311   *
  2312   * @method toAddress
  2313   * @param {String} address
  2314   * @return {String} formatted address
  2315   */
  2316  var toAddress = function (address) {
  2317      if (isStrictAddress(address)) {
  2318          return address;
  2319      }
  2320  
  2321      if (/^[0-9a-f]{40}$/.test(address)) {
  2322          return '0x' + address;
  2323      }
  2324  
  2325      return '0x' + padLeft(toHex(address).substr(2), 40);
  2326  };
  2327  
  2328  /**
  2329   * Returns true if object is BigNumber, otherwise false
  2330   *
  2331   * @method isBigNumber
  2332   * @param {Object}
  2333   * @return {Boolean}
  2334   */
  2335  var isBigNumber = function (object) {
  2336      return object instanceof BigNumber ||
  2337          (object && object.constructor && object.constructor.name === 'BigNumber');
  2338  };
  2339  
  2340  /**
  2341   * Returns true if object is string, otherwise false
  2342   *
  2343   * @method isString
  2344   * @param {Object}
  2345   * @return {Boolean}
  2346   */
  2347  var isString = function (object) {
  2348      return typeof object === 'string' ||
  2349          (object && object.constructor && object.constructor.name === 'String');
  2350  };
  2351  
  2352  /**
  2353   * Returns true if object is function, otherwise false
  2354   *
  2355   * @method isFunction
  2356   * @param {Object}
  2357   * @return {Boolean}
  2358   */
  2359  var isFunction = function (object) {
  2360      return typeof object === 'function';
  2361  };
  2362  
  2363  /**
  2364   * Returns true if object is Objet, otherwise false
  2365   *
  2366   * @method isObject
  2367   * @param {Object}
  2368   * @return {Boolean}
  2369   */
  2370  var isObject = function (object) {
  2371      return object !== null && !(object instanceof Array) && typeof object === 'object';
  2372  };
  2373  
  2374  /**
  2375   * Returns true if object is boolean, otherwise false
  2376   *
  2377   * @method isBoolean
  2378   * @param {Object}
  2379   * @return {Boolean}
  2380   */
  2381  var isBoolean = function (object) {
  2382      return typeof object === 'boolean';
  2383  };
  2384  
  2385  /**
  2386   * Returns true if object is array, otherwise false
  2387   *
  2388   * @method isArray
  2389   * @param {Object}
  2390   * @return {Boolean}
  2391   */
  2392  var isArray = function (object) {
  2393      return object instanceof Array;
  2394  };
  2395  
  2396  /**
  2397   * Returns true if given string is valid json object
  2398   *
  2399   * @method isJson
  2400   * @param {String}
  2401   * @return {Boolean}
  2402   */
  2403  var isJson = function (str) {
  2404      try {
  2405          return !!JSON.parse(str);
  2406      } catch (e) {
  2407          return false;
  2408      }
  2409  };
  2410  
  2411  /**
  2412   * Returns true if given string is a valid Ebakus block header bloom.
  2413   *
  2414   * @method isBloom
  2415   * @param {String} hex encoded bloom filter
  2416   * @return {Boolean}
  2417   */
  2418  var isBloom = function (bloom) {
  2419      if (!/^(0x)?[0-9a-f]{512}$/i.test(bloom)) {
  2420          return false;
  2421      } else if (/^(0x)?[0-9a-f]{512}$/.test(bloom) || /^(0x)?[0-9A-F]{512}$/.test(bloom)) {
  2422          return true;
  2423      }
  2424      return false;
  2425  };
  2426  
  2427  /**
  2428   * Returns true if given string is a valid log topic.
  2429   *
  2430   * @method isTopic
  2431   * @param {String} hex encoded topic
  2432   * @return {Boolean}
  2433   */
  2434  var isTopic = function (topic) {
  2435      if (!/^(0x)?[0-9a-f]{64}$/i.test(topic)) {
  2436          return false;
  2437      } else if (/^(0x)?[0-9a-f]{64}$/.test(topic) || /^(0x)?[0-9A-F]{64}$/.test(topic)) {
  2438          return true;
  2439      }
  2440      return false;
  2441  };
  2442  
  2443  module.exports = {
  2444      padLeft: padLeft,
  2445      padRight: padRight,
  2446      toHex: toHex,
  2447      toDecimal: toDecimal,
  2448      fromDecimal: fromDecimal,
  2449      toUtf8: toUtf8,
  2450      toAscii: toAscii,
  2451      fromUtf8: fromUtf8,
  2452      fromAscii: fromAscii,
  2453      transformToFullName: transformToFullName,
  2454      extractDisplayName: extractDisplayName,
  2455      extractTypeName: extractTypeName,
  2456      toWei: toWei,
  2457      fromWei: fromWei,
  2458      toBigNumber: toBigNumber,
  2459      toTwosComplement: toTwosComplement,
  2460      toAddress: toAddress,
  2461      isBigNumber: isBigNumber,
  2462      isStrictAddress: isStrictAddress,
  2463      isAddress: isAddress,
  2464      isChecksumAddress: isChecksumAddress,
  2465      toChecksumAddress: toChecksumAddress,
  2466      isFunction: isFunction,
  2467      isString: isString,
  2468      isObject: isObject,
  2469      isBoolean: isBoolean,
  2470      isArray: isArray,
  2471      isJson: isJson,
  2472      isBloom: isBloom,
  2473      isTopic: isTopic,
  2474  };
  2475  
  2476  },{"./sha3.js":19,"bignumber.js":"bignumber.js","utf8":85}],21:[function(require,module,exports){
  2477  module.exports={
  2478      "version": "0.20.1"
  2479  }
  2480  
  2481  },{}],22:[function(require,module,exports){
  2482  /*
  2483      This file is part of web3.js.
  2484  
  2485      web3.js is free software: you can redistribute it and/or modify
  2486      it under the terms of the GNU Lesser General Public License as published by
  2487      the Free Software Foundation, either version 3 of the License, or
  2488      (at your option) any later version.
  2489  
  2490      web3.js is distributed in the hope that it will be useful,
  2491      but WITHOUT ANY WARRANTY; without even the implied warranty of
  2492      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2493      GNU Lesser General Public License for more details.
  2494  
  2495      You should have received a copy of the GNU Lesser General Public License
  2496      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  2497  */
  2498  /**
  2499   * @file web3.js
  2500   * @authors:
  2501   *   Jeffrey Wilcke <jeff@ethdev.com>
  2502   *   Marek Kotewicz <marek@ethdev.com>
  2503   *   Marian Oancea <marian@ethdev.com>
  2504   *   Fabian Vogelsteller <fabian@ethdev.com>
  2505   *   Gav Wood <g@ethdev.com>
  2506   * @date 2014
  2507   */
  2508  
  2509  var RequestManager = require('./web3/requestmanager');
  2510  var Iban = require('./web3/iban');
  2511  var Eth = require('./web3/methods/eth');
  2512  var DB = require('./web3/methods/db');
  2513  var Shh = require('./web3/methods/shh');
  2514  var Net = require('./web3/methods/net');
  2515  var Personal = require('./web3/methods/personal');
  2516  var Swarm = require('./web3/methods/swarm');
  2517  var Settings = require('./web3/settings');
  2518  var version = require('./version.json');
  2519  var utils = require('./utils/utils');
  2520  var sha3 = require('./utils/sha3');
  2521  var extend = require('./web3/extend');
  2522  var Batch = require('./web3/batch');
  2523  var Property = require('./web3/property');
  2524  var HttpProvider = require('./web3/httpprovider');
  2525  var IpcProvider = require('./web3/ipcprovider');
  2526  var BigNumber = require('bignumber.js');
  2527  
  2528  
  2529  
  2530  function Web3 (provider) {
  2531      this._requestManager = new RequestManager(provider);
  2532      this.currentProvider = provider;
  2533      this.eth = new Eth(this);
  2534      this.db = new DB(this);
  2535      this.shh = new Shh(this);
  2536      this.net = new Net(this);
  2537      this.personal = new Personal(this);
  2538      this.bzz = new Swarm(this);
  2539      this.settings = new Settings();
  2540      this.version = {
  2541          api: version.version
  2542      };
  2543      this.providers = {
  2544          HttpProvider: HttpProvider,
  2545          IpcProvider: IpcProvider
  2546      };
  2547      this._extend = extend(this);
  2548      this._extend({
  2549          properties: properties()
  2550      });
  2551  }
  2552  
  2553  // expose providers on the class
  2554  Web3.providers = {
  2555      HttpProvider: HttpProvider,
  2556      IpcProvider: IpcProvider
  2557  };
  2558  
  2559  Web3.prototype.setProvider = function (provider) {
  2560      this._requestManager.setProvider(provider);
  2561      this.currentProvider = provider;
  2562  };
  2563  
  2564  Web3.prototype.reset = function (keepIsSyncing) {
  2565      this._requestManager.reset(keepIsSyncing);
  2566      this.settings = new Settings();
  2567  };
  2568  
  2569  Web3.prototype.BigNumber = BigNumber;
  2570  Web3.prototype.toHex = utils.toHex;
  2571  Web3.prototype.toAscii = utils.toAscii;
  2572  Web3.prototype.toUtf8 = utils.toUtf8;
  2573  Web3.prototype.fromAscii = utils.fromAscii;
  2574  Web3.prototype.fromUtf8 = utils.fromUtf8;
  2575  Web3.prototype.toDecimal = utils.toDecimal;
  2576  Web3.prototype.fromDecimal = utils.fromDecimal;
  2577  Web3.prototype.toBigNumber = utils.toBigNumber;
  2578  Web3.prototype.toWei = utils.toWei;
  2579  Web3.prototype.fromWei = utils.fromWei;
  2580  Web3.prototype.isAddress = utils.isAddress;
  2581  Web3.prototype.isChecksumAddress = utils.isChecksumAddress;
  2582  Web3.prototype.toChecksumAddress = utils.toChecksumAddress;
  2583  Web3.prototype.isIBAN = utils.isIBAN;
  2584  Web3.prototype.padLeft = utils.padLeft;
  2585  Web3.prototype.padRight = utils.padRight;
  2586  
  2587  
  2588  Web3.prototype.sha3 = function(string, options) {
  2589      return '0x' + sha3(string, options);
  2590  };
  2591  
  2592  /**
  2593   * Transforms direct icap to address
  2594   */
  2595  Web3.prototype.fromICAP = function (icap) {
  2596      var iban = new Iban(icap);
  2597      return iban.address();
  2598  };
  2599  
  2600  var properties = function () {
  2601      return [
  2602          new Property({
  2603              name: 'version.node',
  2604              getter: 'web3_clientVersion'
  2605          }),
  2606          new Property({
  2607              name: 'version.network',
  2608              getter: 'net_version',
  2609              inputFormatter: utils.toDecimal
  2610          }),
  2611          new Property({
  2612              name: 'version.ebakus',
  2613              getter: 'eth_protocolVersion',
  2614              inputFormatter: utils.toDecimal
  2615          }),
  2616          new Property({
  2617              name: 'version.whisper',
  2618              getter: 'shh_version',
  2619              inputFormatter: utils.toDecimal
  2620          })
  2621      ];
  2622  };
  2623  
  2624  Web3.prototype.isConnected = function(){
  2625      return (this.currentProvider && this.currentProvider.isConnected());
  2626  };
  2627  
  2628  Web3.prototype.createBatch = function () {
  2629      return new Batch(this);
  2630  };
  2631  
  2632  module.exports = Web3;
  2633  
  2634  
  2635  },{"./utils/sha3":19,"./utils/utils":20,"./version.json":21,"./web3/batch":24,"./web3/extend":28,"./web3/httpprovider":32,"./web3/iban":33,"./web3/ipcprovider":34,"./web3/methods/db":37,"./web3/methods/eth":38,"./web3/methods/net":39,"./web3/methods/personal":40,"./web3/methods/shh":41,"./web3/methods/swarm":42,"./web3/property":45,"./web3/requestmanager":46,"./web3/settings":47,"bignumber.js":"bignumber.js"}],23:[function(require,module,exports){
  2636  /*
  2637      This file is part of web3.js.
  2638  
  2639      web3.js is free software: you can redistribute it and/or modify
  2640      it under the terms of the GNU Lesser General Public License as published by
  2641      the Free Software Foundation, either version 3 of the License, or
  2642      (at your option) any later version.
  2643  
  2644      web3.js is distributed in the hope that it will be useful,
  2645      but WITHOUT ANY WARRANTY; without even the implied warranty of
  2646      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2647      GNU Lesser General Public License for more details.
  2648  
  2649      You should have received a copy of the GNU Lesser General Public License
  2650      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  2651  */
  2652  /**
  2653   * @file allevents.js
  2654   * @author Marek Kotewicz <marek@ethdev.com>
  2655   * @date 2014
  2656   */
  2657  
  2658  var sha3 = require('../utils/sha3');
  2659  var SolidityEvent = require('./event');
  2660  var formatters = require('./formatters');
  2661  var utils = require('../utils/utils');
  2662  var Filter = require('./filter');
  2663  var watches = require('./methods/watches');
  2664  
  2665  var AllSolidityEvents = function (requestManager, json, address) {
  2666      this._requestManager = requestManager;
  2667      this._json = json;
  2668      this._address = address;
  2669  };
  2670  
  2671  AllSolidityEvents.prototype.encode = function (options) {
  2672      options = options || {};
  2673      var result = {};
  2674  
  2675      ['fromBlock', 'toBlock'].filter(function (f) {
  2676          return options[f] !== undefined;
  2677      }).forEach(function (f) {
  2678          result[f] = formatters.inputBlockNumberFormatter(options[f]);
  2679      });
  2680  
  2681      result.address = this._address;
  2682  
  2683      return result;
  2684  };
  2685  
  2686  AllSolidityEvents.prototype.decode = function (data) {
  2687      data.data = data.data || '';
  2688      data.topics = data.topics || [];
  2689  
  2690      var eventTopic = data.topics[0].slice(2);
  2691      var match = this._json.filter(function (j) {
  2692          return eventTopic === sha3(utils.transformToFullName(j));
  2693      })[0];
  2694  
  2695      if (!match) { // cannot find matching event?
  2696          console.warn('cannot find event for log');
  2697          return data;
  2698      }
  2699  
  2700      var event = new SolidityEvent(this._requestManager, match, this._address);
  2701      return event.decode(data);
  2702  };
  2703  
  2704  AllSolidityEvents.prototype.execute = function (options, callback) {
  2705  
  2706      if (utils.isFunction(arguments[arguments.length - 1])) {
  2707          callback = arguments[arguments.length - 1];
  2708          if(arguments.length === 1)
  2709              options = null;
  2710      }
  2711  
  2712      var o = this.encode(options);
  2713      var formatter = this.decode.bind(this);
  2714      return new Filter(o, 'eth', this._requestManager, watches.eth(), formatter, callback);
  2715  };
  2716  
  2717  AllSolidityEvents.prototype.attachToContract = function (contract) {
  2718      var execute = this.execute.bind(this);
  2719      contract.allEvents = execute;
  2720  };
  2721  
  2722  module.exports = AllSolidityEvents;
  2723  
  2724  
  2725  },{"../utils/sha3":19,"../utils/utils":20,"./event":27,"./filter":29,"./formatters":30,"./methods/watches":43}],24:[function(require,module,exports){
  2726  /*
  2727      This file is part of web3.js.
  2728  
  2729      web3.js is free software: you can redistribute it and/or modify
  2730      it under the terms of the GNU Lesser General Public License as published by
  2731      the Free Software Foundation, either version 3 of the License, or
  2732      (at your option) any later version.
  2733  
  2734      web3.js is distributed in the hope that it will be useful,
  2735      but WITHOUT ANY WARRANTY; without even the implied warranty of
  2736      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2737      GNU Lesser General Public License for more details.
  2738  
  2739      You should have received a copy of the GNU Lesser General Public License
  2740      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  2741  */
  2742  /**
  2743   * @file batch.js
  2744   * @author Marek Kotewicz <marek@ethdev.com>
  2745   * @date 2015
  2746   */
  2747  
  2748  var Jsonrpc = require('./jsonrpc');
  2749  var errors = require('./errors');
  2750  
  2751  var Batch = function (web3) {
  2752      this.requestManager = web3._requestManager;
  2753      this.requests = [];
  2754  };
  2755  
  2756  /**
  2757   * Should be called to add create new request to batch request
  2758   *
  2759   * @method add
  2760   * @param {Object} jsonrpc requet object
  2761   */
  2762  Batch.prototype.add = function (request) {
  2763      this.requests.push(request);
  2764  };
  2765  
  2766  /**
  2767   * Should be called to execute batch request
  2768   *
  2769   * @method execute
  2770   */
  2771  Batch.prototype.execute = function () {
  2772      var requests = this.requests;
  2773      this.requestManager.sendBatch(requests, function (err, results) {
  2774          results = results || [];
  2775          requests.map(function (request, index) {
  2776              return results[index] || {};
  2777          }).forEach(function (result, index) {
  2778              if (requests[index].callback) {
  2779  
  2780                  if (!Jsonrpc.isValidResponse(result)) {
  2781                      return requests[index].callback(errors.InvalidResponse(result));
  2782                  }
  2783  
  2784                  requests[index].callback(null, (requests[index].format ? requests[index].format(result.result) : result.result));
  2785              }
  2786          });
  2787      });
  2788  };
  2789  
  2790  module.exports = Batch;
  2791  
  2792  
  2793  },{"./errors":26,"./jsonrpc":35}],25:[function(require,module,exports){
  2794  /*
  2795      This file is part of web3.js.
  2796  
  2797      web3.js is free software: you can redistribute it and/or modify
  2798      it under the terms of the GNU Lesser General Public License as published by
  2799      the Free Software Foundation, either version 3 of the License, or
  2800      (at your option) any later version.
  2801  
  2802      web3.js is distributed in the hope that it will be useful,
  2803      but WITHOUT ANY WARRANTY; without even the implied warranty of
  2804      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2805      GNU Lesser General Public License for more details.
  2806  
  2807      You should have received a copy of the GNU Lesser General Public License
  2808      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  2809  */
  2810  /**
  2811   * @file contract.js
  2812   * @author Marek Kotewicz <marek@ethdev.com>
  2813   * @date 2014
  2814   */
  2815  
  2816  var utils = require('../utils/utils');
  2817  var coder = require('../solidity/coder');
  2818  var SolidityEvent = require('./event');
  2819  var SolidityFunction = require('./function');
  2820  var AllEvents = require('./allevents');
  2821  
  2822  /**
  2823   * Should be called to encode constructor params
  2824   *
  2825   * @method encodeConstructorParams
  2826   * @param {Array} abi
  2827   * @param {Array} constructor params
  2828   */
  2829  var encodeConstructorParams = function (abi, params) {
  2830      return abi.filter(function (json) {
  2831          return json.type === 'constructor' && json.inputs.length === params.length;
  2832      }).map(function (json) {
  2833          return json.inputs.map(function (input) {
  2834              return input.type;
  2835          });
  2836      }).map(function (types) {
  2837          return coder.encodeParams(types, params);
  2838      })[0] || '';
  2839  };
  2840  
  2841  /**
  2842   * Should be called to add functions to contract object
  2843   *
  2844   * @method addFunctionsToContract
  2845   * @param {Contract} contract
  2846   * @param {Array} abi
  2847   */
  2848  var addFunctionsToContract = function (contract) {
  2849      contract.abi.filter(function (json) {
  2850          return json.type === 'function';
  2851      }).map(function (json) {
  2852          return new SolidityFunction(contract._eth, json, contract.address);
  2853      }).forEach(function (f) {
  2854          f.attachToContract(contract);
  2855      });
  2856  };
  2857  
  2858  /**
  2859   * Should be called to add events to contract object
  2860   *
  2861   * @method addEventsToContract
  2862   * @param {Contract} contract
  2863   * @param {Array} abi
  2864   */
  2865  var addEventsToContract = function (contract) {
  2866      var events = contract.abi.filter(function (json) {
  2867          return json.type === 'event';
  2868      });
  2869  
  2870      var All = new AllEvents(contract._eth._requestManager, events, contract.address);
  2871      All.attachToContract(contract);
  2872  
  2873      events.map(function (json) {
  2874          return new SolidityEvent(contract._eth._requestManager, json, contract.address);
  2875      }).forEach(function (e) {
  2876          e.attachToContract(contract);
  2877      });
  2878  };
  2879  
  2880  
  2881  /**
  2882   * Should be called to check if the contract gets properly deployed on the blockchain.
  2883   *
  2884   * @method checkForContractAddress
  2885   * @param {Object} contract
  2886   * @param {Function} callback
  2887   * @returns {Undefined}
  2888   */
  2889  var checkForContractAddress = function(contract, callback){
  2890      var count = 0,
  2891          callbackFired = false;
  2892  
  2893      // wait for receipt
  2894      var filter = contract._eth.filter('latest', function(e){
  2895          if (!e && !callbackFired) {
  2896              count++;
  2897  
  2898              // stop watching after 50 blocks (timeout)
  2899              if (count > 50) {
  2900  
  2901                  filter.stopWatching(function() {});
  2902                  callbackFired = true;
  2903  
  2904                  if (callback)
  2905                      callback(new Error('Contract transaction couldn\'t be found after 50 blocks'));
  2906                  else
  2907                      throw new Error('Contract transaction couldn\'t be found after 50 blocks');
  2908  
  2909  
  2910              } else {
  2911  
  2912                  contract._eth.getTransactionReceipt(contract.transactionHash, function(e, receipt){
  2913                      if(receipt && !callbackFired) {
  2914  
  2915                          contract._eth.getCode(receipt.contractAddress, function(e, code){
  2916                              /*jshint maxcomplexity: 6 */
  2917  
  2918                              if(callbackFired || !code)
  2919                                  return;
  2920  
  2921                              filter.stopWatching(function() {});
  2922                              callbackFired = true;
  2923  
  2924                              if(code.length > 3) {
  2925  
  2926                                  // console.log('Contract code deployed!');
  2927  
  2928                                  contract.address = receipt.contractAddress;
  2929  
  2930                                  // attach events and methods again after we have
  2931                                  addFunctionsToContract(contract);
  2932                                  addEventsToContract(contract);
  2933  
  2934                                  // call callback for the second time
  2935                                  if(callback)
  2936                                      callback(null, contract);
  2937  
  2938                              } else {
  2939                                  if(callback)
  2940                                      callback(new Error('The contract code couldn\'t be stored, please check your gas amount.'));
  2941                                  else
  2942                                      throw new Error('The contract code couldn\'t be stored, please check your gas amount.');
  2943                              }
  2944                          });
  2945                      }
  2946                  });
  2947              }
  2948          }
  2949      });
  2950  };
  2951  
  2952  /**
  2953   * Should be called to create new ContractFactory instance
  2954   *
  2955   * @method ContractFactory
  2956   * @param {Array} abi
  2957   */
  2958  var ContractFactory = function (eth, abi) {
  2959      this.eth = eth;
  2960      this.abi = abi;
  2961  
  2962      /**
  2963       * Should be called to create new contract on a blockchain
  2964       *
  2965       * @method new
  2966       * @param {Any} contract constructor param1 (optional)
  2967       * @param {Any} contract constructor param2 (optional)
  2968       * @param {Object} contract transaction object (required)
  2969       * @param {Function} callback
  2970       * @returns {Contract} returns contract instance
  2971       */
  2972      this.new = function () {
  2973          /*jshint maxcomplexity: 7 */
  2974  
  2975          var contract = new Contract(this.eth, this.abi);
  2976  
  2977          // parse arguments
  2978          var options = {}; // required!
  2979          var callback;
  2980  
  2981          var args = Array.prototype.slice.call(arguments);
  2982          if (utils.isFunction(args[args.length - 1])) {
  2983              callback = args.pop();
  2984          }
  2985  
  2986          var last = args[args.length - 1];
  2987          if (utils.isObject(last) && !utils.isArray(last)) {
  2988              options = args.pop();
  2989          }
  2990  
  2991          if (options.value > 0) {
  2992              var constructorAbi = abi.filter(function (json) {
  2993                  return json.type === 'constructor' && json.inputs.length === args.length;
  2994              })[0] || {};
  2995  
  2996              if (!constructorAbi.payable) {
  2997                  throw new Error('Cannot send value to non-payable constructor');
  2998              }
  2999          }
  3000  
  3001          var bytes = encodeConstructorParams(this.abi, args);
  3002          options.data += bytes;
  3003  
  3004          if (callback) {
  3005  
  3006              // wait for the contract address and check if the code was deployed
  3007              this.eth.sendTransaction(options, function (err, hash) {
  3008                  if (err) {
  3009                      callback(err);
  3010                  } else {
  3011                      // add the transaction hash
  3012                      contract.transactionHash = hash;
  3013  
  3014                      // call callback for the first time
  3015                      callback(null, contract);
  3016  
  3017                      checkForContractAddress(contract, callback);
  3018                  }
  3019              });
  3020          } else {
  3021              var hash = this.eth.sendTransaction(options);
  3022              // add the transaction hash
  3023              contract.transactionHash = hash;
  3024              checkForContractAddress(contract);
  3025          }
  3026  
  3027          return contract;
  3028      };
  3029  
  3030      this.new.getData = this.getData.bind(this);
  3031  };
  3032  
  3033  /**
  3034   * Should be called to create new ContractFactory
  3035   *
  3036   * @method contract
  3037   * @param {Array} abi
  3038   * @returns {ContractFactory} new contract factory
  3039   */
  3040  //var contract = function (abi) {
  3041      //return new ContractFactory(abi);
  3042  //};
  3043  
  3044  
  3045  
  3046  /**
  3047   * Should be called to get access to existing contract on a blockchain
  3048   *
  3049   * @method at
  3050   * @param {Address} contract address (required)
  3051   * @param {Function} callback {optional)
  3052   * @returns {Contract} returns contract if no callback was passed,
  3053   * otherwise calls callback function (err, contract)
  3054   */
  3055  ContractFactory.prototype.at = function (address, callback) {
  3056      var contract = new Contract(this.eth, this.abi, address);
  3057  
  3058      // this functions are not part of prototype,
  3059      // because we dont want to spoil the interface
  3060      addFunctionsToContract(contract);
  3061      addEventsToContract(contract);
  3062  
  3063      if (callback) {
  3064          callback(null, contract);
  3065      }
  3066      return contract;
  3067  };
  3068  
  3069  /**
  3070   * Gets the data, which is data to deploy plus constructor params
  3071   *
  3072   * @method getData
  3073   */
  3074  ContractFactory.prototype.getData = function () {
  3075      var options = {}; // required!
  3076      var args = Array.prototype.slice.call(arguments);
  3077  
  3078      var last = args[args.length - 1];
  3079      if (utils.isObject(last) && !utils.isArray(last)) {
  3080          options = args.pop();
  3081      }
  3082  
  3083      var bytes = encodeConstructorParams(this.abi, args);
  3084      options.data += bytes;
  3085  
  3086      return options.data;
  3087  };
  3088  
  3089  /**
  3090   * Should be called to create new contract instance
  3091   *
  3092   * @method Contract
  3093   * @param {Array} abi
  3094   * @param {Address} contract address
  3095   */
  3096  var Contract = function (eth, abi, address) {
  3097      this._eth = eth;
  3098      this.transactionHash = null;
  3099      this.address = address;
  3100      this.abi = abi;
  3101  };
  3102  
  3103  module.exports = ContractFactory;
  3104  
  3105  },{"../solidity/coder":7,"../utils/utils":20,"./allevents":23,"./event":27,"./function":31}],26:[function(require,module,exports){
  3106  /*
  3107      This file is part of web3.js.
  3108  
  3109      web3.js is free software: you can redistribute it and/or modify
  3110      it under the terms of the GNU Lesser General Public License as published by
  3111      the Free Software Foundation, either version 3 of the License, or
  3112      (at your option) any later version.
  3113  
  3114      web3.js is distributed in the hope that it will be useful,
  3115      but WITHOUT ANY WARRANTY; without even the implied warranty of
  3116      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3117      GNU Lesser General Public License for more details.
  3118  
  3119      You should have received a copy of the GNU Lesser General Public License
  3120      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  3121  */
  3122  /**
  3123   * @file errors.js
  3124   * @author Marek Kotewicz <marek@ethdev.com>
  3125   * @date 2015
  3126   */
  3127  
  3128  module.exports = {
  3129      InvalidNumberOfSolidityArgs: function () {
  3130          return new Error('Invalid number of arguments to Solidity function');
  3131      },
  3132      InvalidNumberOfRPCParams: function () {
  3133          return new Error('Invalid number of input parameters to RPC method');
  3134      },
  3135      InvalidConnection: function (host){
  3136          return new Error('CONNECTION ERROR: Couldn\'t connect to node '+ host +'.');
  3137      },
  3138      InvalidProvider: function () {
  3139          return new Error('Provider not set or invalid');
  3140      },
  3141      InvalidResponse: function (result){
  3142          var message = !!result && !!result.error && !!result.error.message ? result.error.message : 'Invalid JSON RPC response: ' + JSON.stringify(result);
  3143          return new Error(message);
  3144      },
  3145      ConnectionTimeout: function (ms){
  3146          return new Error('CONNECTION TIMEOUT: timeout of ' + ms + ' ms achived');
  3147      }
  3148  };
  3149  
  3150  },{}],27:[function(require,module,exports){
  3151  /*
  3152      This file is part of web3.js.
  3153  
  3154      web3.js is free software: you can redistribute it and/or modify
  3155      it under the terms of the GNU Lesser General Public License as published by
  3156      the Free Software Foundation, either version 3 of the License, or
  3157      (at your option) any later version.
  3158  
  3159      web3.js is distributed in the hope that it will be useful,
  3160      but WITHOUT ANY WARRANTY; without even the implied warranty of
  3161      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3162      GNU Lesser General Public License for more details.
  3163  
  3164      You should have received a copy of the GNU Lesser General Public License
  3165      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  3166  */
  3167  /**
  3168   * @file event.js
  3169   * @author Marek Kotewicz <marek@ethdev.com>
  3170   * @date 2014
  3171   */
  3172  
  3173  var utils = require('../utils/utils');
  3174  var coder = require('../solidity/coder');
  3175  var formatters = require('./formatters');
  3176  var sha3 = require('../utils/sha3');
  3177  var Filter = require('./filter');
  3178  var watches = require('./methods/watches');
  3179  
  3180  /**
  3181   * This prototype should be used to create event filters
  3182   */
  3183  var SolidityEvent = function (requestManager, json, address) {
  3184      this._requestManager = requestManager;
  3185      this._params = json.inputs;
  3186      this._name = utils.transformToFullName(json);
  3187      this._address = address;
  3188      this._anonymous = json.anonymous;
  3189  };
  3190  
  3191  /**
  3192   * Should be used to get filtered param types
  3193   *
  3194   * @method types
  3195   * @param {Bool} decide if returned typed should be indexed
  3196   * @return {Array} array of types
  3197   */
  3198  SolidityEvent.prototype.types = function (indexed) {
  3199      return this._params.filter(function (i) {
  3200          return i.indexed === indexed;
  3201      }).map(function (i) {
  3202          return i.type;
  3203      });
  3204  };
  3205  
  3206  /**
  3207   * Should be used to get event display name
  3208   *
  3209   * @method displayName
  3210   * @return {String} event display name
  3211   */
  3212  SolidityEvent.prototype.displayName = function () {
  3213      return utils.extractDisplayName(this._name);
  3214  };
  3215  
  3216  /**
  3217   * Should be used to get event type name
  3218   *
  3219   * @method typeName
  3220   * @return {String} event type name
  3221   */
  3222  SolidityEvent.prototype.typeName = function () {
  3223      return utils.extractTypeName(this._name);
  3224  };
  3225  
  3226  /**
  3227   * Should be used to get event signature
  3228   *
  3229   * @method signature
  3230   * @return {String} event signature
  3231   */
  3232  SolidityEvent.prototype.signature = function () {
  3233      return sha3(this._name);
  3234  };
  3235  
  3236  /**
  3237   * Should be used to encode indexed params and options to one final object
  3238   *
  3239   * @method encode
  3240   * @param {Object} indexed
  3241   * @param {Object} options
  3242   * @return {Object} everything combined together and encoded
  3243   */
  3244  SolidityEvent.prototype.encode = function (indexed, options) {
  3245      indexed = indexed || {};
  3246      options = options || {};
  3247      var result = {};
  3248  
  3249      ['fromBlock', 'toBlock'].filter(function (f) {
  3250          return options[f] !== undefined;
  3251      }).forEach(function (f) {
  3252          result[f] = formatters.inputBlockNumberFormatter(options[f]);
  3253      });
  3254  
  3255      result.topics = [];
  3256  
  3257      result.address = this._address;
  3258      if (!this._anonymous) {
  3259          result.topics.push('0x' + this.signature());
  3260      }
  3261  
  3262      var indexedTopics = this._params.filter(function (i) {
  3263          return i.indexed === true;
  3264      }).map(function (i) {
  3265          var value = indexed[i.name];
  3266          if (value === undefined || value === null) {
  3267              return null;
  3268          }
  3269  
  3270          if (utils.isArray(value)) {
  3271              return value.map(function (v) {
  3272                  return '0x' + coder.encodeParam(i.type, v);
  3273              });
  3274          }
  3275          return '0x' + coder.encodeParam(i.type, value);
  3276      });
  3277  
  3278      result.topics = result.topics.concat(indexedTopics);
  3279  
  3280      return result;
  3281  };
  3282  
  3283  /**
  3284   * Should be used to decode indexed params and options
  3285   *
  3286   * @method decode
  3287   * @param {Object} data
  3288   * @return {Object} result object with decoded indexed && not indexed params
  3289   */
  3290  SolidityEvent.prototype.decode = function (data) {
  3291  
  3292      data.data = data.data || '';
  3293      data.topics = data.topics || [];
  3294  
  3295      var argTopics = this._anonymous ? data.topics : data.topics.slice(1);
  3296      var indexedData = argTopics.map(function (topics) { return topics.slice(2); }).join("");
  3297      var indexedParams = coder.decodeParams(this.types(true), indexedData);
  3298  
  3299      var notIndexedData = data.data.slice(2);
  3300      var notIndexedParams = coder.decodeParams(this.types(false), notIndexedData);
  3301  
  3302      var result = formatters.outputLogFormatter(data);
  3303      result.event = this.displayName();
  3304      result.address = data.address;
  3305  
  3306      result.args = this._params.reduce(function (acc, current) {
  3307          acc[current.name] = current.indexed ? indexedParams.shift() : notIndexedParams.shift();
  3308          return acc;
  3309      }, {});
  3310  
  3311      delete result.data;
  3312      delete result.topics;
  3313  
  3314      return result;
  3315  };
  3316  
  3317  /**
  3318   * Should be used to create new filter object from event
  3319   *
  3320   * @method execute
  3321   * @param {Object} indexed
  3322   * @param {Object} options
  3323   * @return {Object} filter object
  3324   */
  3325  SolidityEvent.prototype.execute = function (indexed, options, callback) {
  3326  
  3327      if (utils.isFunction(arguments[arguments.length - 1])) {
  3328          callback = arguments[arguments.length - 1];
  3329          if(arguments.length === 2)
  3330              options = null;
  3331          if(arguments.length === 1) {
  3332              options = null;
  3333              indexed = {};
  3334          }
  3335      }
  3336  
  3337      var o = this.encode(indexed, options);
  3338      var formatter = this.decode.bind(this);
  3339      return new Filter(o, 'eth', this._requestManager, watches.eth(), formatter, callback);
  3340  };
  3341  
  3342  /**
  3343   * Should be used to attach event to contract object
  3344   *
  3345   * @method attachToContract
  3346   * @param {Contract}
  3347   */
  3348  SolidityEvent.prototype.attachToContract = function (contract) {
  3349      var execute = this.execute.bind(this);
  3350      var displayName = this.displayName();
  3351      if (!contract[displayName]) {
  3352          contract[displayName] = execute;
  3353      }
  3354      contract[displayName][this.typeName()] = this.execute.bind(this, contract);
  3355  };
  3356  
  3357  module.exports = SolidityEvent;
  3358  
  3359  
  3360  },{"../solidity/coder":7,"../utils/sha3":19,"../utils/utils":20,"./filter":29,"./formatters":30,"./methods/watches":43}],28:[function(require,module,exports){
  3361  var formatters = require('./formatters');
  3362  var utils = require('./../utils/utils');
  3363  var Method = require('./method');
  3364  var Property = require('./property');
  3365  
  3366  // TODO: refactor, so the input params are not altered.
  3367  // it's necessary to make same 'extension' work with multiple providers
  3368  var extend = function (web3) {
  3369      /* jshint maxcomplexity:5 */
  3370      var ex = function (extension) {
  3371  
  3372          var extendedObject;
  3373          if (extension.property) {
  3374              if (!web3[extension.property]) {
  3375                  web3[extension.property] = {};
  3376              }
  3377              extendedObject = web3[extension.property];
  3378          } else {
  3379              extendedObject = web3;
  3380          }
  3381  
  3382          if (extension.methods) {
  3383              extension.methods.forEach(function (method) {
  3384                  method.attachToObject(extendedObject);
  3385                  method.setRequestManager(web3._requestManager);
  3386              });
  3387          }
  3388  
  3389          if (extension.properties) {
  3390              extension.properties.forEach(function (property) {
  3391                  property.attachToObject(extendedObject);
  3392                  property.setRequestManager(web3._requestManager);
  3393              });
  3394          }
  3395      };
  3396  
  3397      ex.formatters = formatters;
  3398      ex.utils = utils;
  3399      ex.Method = Method;
  3400      ex.Property = Property;
  3401  
  3402      return ex;
  3403  };
  3404  
  3405  
  3406  
  3407  module.exports = extend;
  3408  
  3409  
  3410  },{"./../utils/utils":20,"./formatters":30,"./method":36,"./property":45}],29:[function(require,module,exports){
  3411  /*
  3412      This file is part of web3.js.
  3413  
  3414      web3.js is free software: you can redistribute it and/or modify
  3415      it under the terms of the GNU Lesser General Public License as published by
  3416      the Free Software Foundation, either version 3 of the License, or
  3417      (at your option) any later version.
  3418  
  3419      web3.js is distributed in the hope that it will be useful,
  3420      but WITHOUT ANY WARRANTY; without even the implied warranty of
  3421      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3422      GNU Lesser General Public License for more details.
  3423  
  3424      You should have received a copy of the GNU Lesser General Public License
  3425      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  3426  */
  3427  /** @file filter.js
  3428   * @authors:
  3429   *   Jeffrey Wilcke <jeff@ethdev.com>
  3430   *   Marek Kotewicz <marek@ethdev.com>
  3431   *   Marian Oancea <marian@ethdev.com>
  3432   *   Fabian Vogelsteller <fabian@ethdev.com>
  3433   *   Gav Wood <g@ethdev.com>
  3434   * @date 2014
  3435   */
  3436  
  3437  var formatters = require('./formatters');
  3438  var utils = require('../utils/utils');
  3439  
  3440  /**
  3441  * Converts a given topic to a hex string, but also allows null values.
  3442  *
  3443  * @param {Mixed} value
  3444  * @return {String}
  3445  */
  3446  var toTopic = function(value){
  3447  
  3448      if(value === null || typeof value === 'undefined')
  3449          return null;
  3450  
  3451      value = String(value);
  3452  
  3453      if(value.indexOf('0x') === 0)
  3454          return value;
  3455      else
  3456          return utils.fromUtf8(value);
  3457  };
  3458  
  3459  /// This method should be called on options object, to verify deprecated properties && lazy load dynamic ones
  3460  /// @param should be string or object
  3461  /// @returns options string or object
  3462  var getOptions = function (options, type) {
  3463      /*jshint maxcomplexity: 6 */
  3464  
  3465      if (utils.isString(options)) {
  3466          return options;
  3467      }
  3468  
  3469      options = options || {};
  3470  
  3471  
  3472      switch(type) {
  3473          case 'eth':
  3474  
  3475              // make sure topics, get converted to hex
  3476              options.topics = options.topics || [];
  3477              options.topics = options.topics.map(function(topic){
  3478                  return (utils.isArray(topic)) ? topic.map(toTopic) : toTopic(topic);
  3479              });
  3480  
  3481              return {
  3482                  topics: options.topics,
  3483                  from: options.from,
  3484                  to: options.to,
  3485                  address: options.address,
  3486                  fromBlock: formatters.inputBlockNumberFormatter(options.fromBlock),
  3487                  toBlock: formatters.inputBlockNumberFormatter(options.toBlock)
  3488              };
  3489          case 'shh':
  3490              return options;
  3491      }
  3492  };
  3493  
  3494  /**
  3495  Adds the callback and sets up the methods, to iterate over the results.
  3496  
  3497  @method getLogsAtStart
  3498  @param {Object} self
  3499  @param {function} callback
  3500  */
  3501  var getLogsAtStart = function(self, callback){
  3502      // call getFilterLogs for the first watch callback start
  3503      if (!utils.isString(self.options)) {
  3504          self.get(function (err, messages) {
  3505              // don't send all the responses to all the watches again... just to self one
  3506              if (err) {
  3507                  callback(err);
  3508              }
  3509  
  3510              if(utils.isArray(messages)) {
  3511                  messages.forEach(function (message) {
  3512                      callback(null, message);
  3513                  });
  3514              }
  3515          });
  3516      }
  3517  };
  3518  
  3519  /**
  3520  Adds the callback and sets up the methods, to iterate over the results.
  3521  
  3522  @method pollFilter
  3523  @param {Object} self
  3524  */
  3525  var pollFilter = function(self) {
  3526  
  3527      var onMessage = function (error, messages) {
  3528          if (error) {
  3529              return self.callbacks.forEach(function (callback) {
  3530                  callback(error);
  3531              });
  3532          }
  3533  
  3534          if(utils.isArray(messages)) {
  3535              messages.forEach(function (message) {
  3536                  message = self.formatter ? self.formatter(message) : message;
  3537                  self.callbacks.forEach(function (callback) {
  3538                      callback(null, message);
  3539                  });
  3540              });
  3541          }
  3542      };
  3543  
  3544      self.requestManager.startPolling({
  3545          method: self.implementation.poll.call,
  3546          params: [self.filterId],
  3547      }, self.filterId, onMessage, self.stopWatching.bind(self));
  3548  
  3549  };
  3550  
  3551  var Filter = function (options, type, requestManager, methods, formatter, callback, filterCreationErrorCallback) {
  3552      var self = this;
  3553      var implementation = {};
  3554      methods.forEach(function (method) {
  3555          method.setRequestManager(requestManager);
  3556          method.attachToObject(implementation);
  3557      });
  3558      this.requestManager = requestManager;
  3559      this.options = getOptions(options, type);
  3560      this.implementation = implementation;
  3561      this.filterId = null;
  3562      this.callbacks = [];
  3563      this.getLogsCallbacks = [];
  3564      this.pollFilters = [];
  3565      this.formatter = formatter;
  3566      this.implementation.newFilter(this.options, function(error, id){
  3567          if(error) {
  3568              self.callbacks.forEach(function(cb){
  3569                  cb(error);
  3570              });
  3571              if (typeof filterCreationErrorCallback === 'function') {
  3572                filterCreationErrorCallback(error);
  3573              }
  3574          } else {
  3575              self.filterId = id;
  3576  
  3577              // check if there are get pending callbacks as a consequence
  3578              // of calling get() with filterId unassigned.
  3579              self.getLogsCallbacks.forEach(function (cb){
  3580                  self.get(cb);
  3581              });
  3582              self.getLogsCallbacks = [];
  3583  
  3584              // get filter logs for the already existing watch calls
  3585              self.callbacks.forEach(function(cb){
  3586                  getLogsAtStart(self, cb);
  3587              });
  3588              if(self.callbacks.length > 0)
  3589                  pollFilter(self);
  3590  
  3591              // start to watch immediately
  3592              if(typeof callback === 'function') {
  3593                  return self.watch(callback);
  3594              }
  3595          }
  3596      });
  3597  
  3598      return this;
  3599  };
  3600  
  3601  Filter.prototype.watch = function (callback) {
  3602      this.callbacks.push(callback);
  3603  
  3604      if(this.filterId) {
  3605          getLogsAtStart(this, callback);
  3606          pollFilter(this);
  3607      }
  3608  
  3609      return this;
  3610  };
  3611  
  3612  Filter.prototype.stopWatching = function (callback) {
  3613      this.requestManager.stopPolling(this.filterId);
  3614      this.callbacks = [];
  3615      // remove filter async
  3616      if (callback) {
  3617          this.implementation.uninstallFilter(this.filterId, callback);
  3618      } else {
  3619          return this.implementation.uninstallFilter(this.filterId);
  3620      }
  3621  };
  3622  
  3623  Filter.prototype.get = function (callback) {
  3624      var self = this;
  3625      if (utils.isFunction(callback)) {
  3626          if (this.filterId === null) {
  3627              // If filterId is not set yet, call it back
  3628              // when newFilter() assigns it.
  3629              this.getLogsCallbacks.push(callback);
  3630          } else {
  3631              this.implementation.getLogs(this.filterId, function(err, res){
  3632                  if (err) {
  3633                      callback(err);
  3634                  } else {
  3635                      callback(null, res.map(function (log) {
  3636                          return self.formatter ? self.formatter(log) : log;
  3637                      }));
  3638                  }
  3639              });
  3640          }
  3641      } else {
  3642          if (this.filterId === null) {
  3643              throw new Error('Filter ID Error: filter().get() can\'t be chained synchronous, please provide a callback for the get() method.');
  3644          }
  3645          var logs = this.implementation.getLogs(this.filterId);
  3646          return logs.map(function (log) {
  3647              return self.formatter ? self.formatter(log) : log;
  3648          });
  3649      }
  3650  
  3651      return this;
  3652  };
  3653  
  3654  module.exports = Filter;
  3655  
  3656  
  3657  },{"../utils/utils":20,"./formatters":30}],30:[function(require,module,exports){
  3658  'use strict'
  3659  
  3660  /*
  3661      This file is part of web3.js.
  3662  
  3663      web3.js is free software: you can redistribute it and/or modify
  3664      it under the terms of the GNU Lesser General Public License as published by
  3665      the Free Software Foundation, either version 3 of the License, or
  3666      (at your option) any later version.
  3667  
  3668      web3.js is distributed in the hope that it will be useful,
  3669      but WITHOUT ANY WARRANTY; without even the implied warranty of
  3670      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3671      GNU Lesser General Public License for more details.
  3672  
  3673      You should have received a copy of the GNU Lesser General Public License
  3674      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  3675  */
  3676  /**
  3677   * @file formatters.js
  3678   * @author Marek Kotewicz <marek@ethdev.com>
  3679   * @author Fabian Vogelsteller <fabian@ethdev.com>
  3680   * @date 2015
  3681   */
  3682  
  3683  var utils = require('../utils/utils');
  3684  var config = require('../utils/config');
  3685  var Iban = require('./iban');
  3686  
  3687  /**
  3688   * Should the format output to a big number
  3689   *
  3690   * @method outputBigNumberFormatter
  3691   * @param {String|Number|BigNumber}
  3692   * @returns {BigNumber} object
  3693   */
  3694  var outputBigNumberFormatter = function (number) {
  3695      return utils.toBigNumber(number);
  3696  };
  3697  
  3698  var isPredefinedBlockNumber = function (blockNumber) {
  3699      return blockNumber === 'latest' || blockNumber === 'pending' || blockNumber === 'earliest';
  3700  };
  3701  
  3702  var inputDefaultBlockNumberFormatter = function (blockNumber) {
  3703      if (blockNumber === undefined) {
  3704          return config.defaultBlock;
  3705      }
  3706      return inputBlockNumberFormatter(blockNumber);
  3707  };
  3708  
  3709  var inputBlockNumberFormatter = function (blockNumber) {
  3710      if (blockNumber === undefined) {
  3711          return undefined;
  3712      } else if (isPredefinedBlockNumber(blockNumber)) {
  3713          return blockNumber;
  3714      }
  3715      return utils.toHex(blockNumber);
  3716  };
  3717  
  3718  /**
  3719   * Formats the input of a transaction and converts all values to HEX
  3720   *
  3721   * @method inputCallFormatter
  3722   * @param {Object} transaction options
  3723   * @returns object
  3724  */
  3725  var inputCallFormatter = function (options){
  3726  
  3727      options.from = options.from || config.defaultAccount;
  3728  
  3729      if (options.from) {
  3730          options.from = inputAddressFormatter(options.from);
  3731      }
  3732  
  3733      if (options.to) { // it might be contract creation
  3734          options.to = inputAddressFormatter(options.to);
  3735      }
  3736  
  3737      ['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
  3738          return options[key] !== undefined;
  3739      }).forEach(function(key){
  3740          options[key] = utils.fromDecimal(options[key]);
  3741      });
  3742  
  3743      return options;
  3744  };
  3745  
  3746  /**
  3747   * Formats the input of a transaction and converts all values to HEX
  3748   *
  3749   * @method inputTransactionFormatter
  3750   * @param {Object} transaction options
  3751   * @returns object
  3752  */
  3753  var inputTransactionFormatter = function (options){
  3754  
  3755      options.from = options.from || config.defaultAccount;
  3756      options.from = inputAddressFormatter(options.from);
  3757  
  3758      if (options.to) { // it might be contract creation
  3759          options.to = inputAddressFormatter(options.to);
  3760      }
  3761  
  3762      ['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
  3763          return options[key] !== undefined;
  3764      }).forEach(function(key){
  3765          options[key] = utils.fromDecimal(options[key]);
  3766      });
  3767  
  3768      return options;
  3769  };
  3770  
  3771  /**
  3772   * Formats the output of a transaction to its proper values
  3773   *
  3774   * @method outputTransactionFormatter
  3775   * @param {Object} tx
  3776   * @returns {Object}
  3777  */
  3778  var outputTransactionFormatter = function (tx){
  3779      if(tx.blockNumber !== null)
  3780          tx.blockNumber = utils.toDecimal(tx.blockNumber);
  3781      if(tx.transactionIndex !== null)
  3782          tx.transactionIndex = utils.toDecimal(tx.transactionIndex);
  3783      tx.nonce = utils.toDecimal(tx.nonce);
  3784      tx.gas = utils.toDecimal(tx.gas);
  3785      tx.gasPrice = utils.toBigNumber(tx.gasPrice);
  3786      tx.value = utils.toBigNumber(tx.value);
  3787      return tx;
  3788  };
  3789  
  3790  /**
  3791   * Formats the output of a transaction receipt to its proper values
  3792   *
  3793   * @method outputTransactionReceiptFormatter
  3794   * @param {Object} receipt
  3795   * @returns {Object}
  3796  */
  3797  var outputTransactionReceiptFormatter = function (receipt){
  3798      if(receipt.blockNumber !== null)
  3799          receipt.blockNumber = utils.toDecimal(receipt.blockNumber);
  3800      if(receipt.transactionIndex !== null)
  3801          receipt.transactionIndex = utils.toDecimal(receipt.transactionIndex);
  3802      receipt.cumulativeGasUsed = utils.toDecimal(receipt.cumulativeGasUsed);
  3803      receipt.gasUsed = utils.toDecimal(receipt.gasUsed);
  3804  
  3805      if(utils.isArray(receipt.logs)) {
  3806          receipt.logs = receipt.logs.map(function(log){
  3807              return outputLogFormatter(log);
  3808          });
  3809      }
  3810  
  3811      return receipt;
  3812  };
  3813  
  3814  /**
  3815   * Formats the output of a block to its proper values
  3816   *
  3817   * @method outputBlockFormatter
  3818   * @param {Object} block
  3819   * @returns {Object}
  3820  */
  3821  var outputBlockFormatter = function(block) {
  3822  
  3823      // transform to number
  3824      block.gasLimit = utils.toDecimal(block.gasLimit);
  3825      block.gasUsed = utils.toDecimal(block.gasUsed);
  3826      block.size = utils.toDecimal(block.size);
  3827      block.timestamp = utils.toDecimal(block.timestamp);
  3828      if(block.number !== null)
  3829          block.number = utils.toDecimal(block.number);
  3830  
  3831      if (utils.isArray(block.transactions)) {
  3832          block.transactions.forEach(function(item){
  3833              if(!utils.isString(item))
  3834                  return outputTransactionFormatter(item);
  3835          });
  3836      }
  3837  
  3838      return block;
  3839  };
  3840  
  3841  /**
  3842   * Formats the output of a log
  3843   *
  3844   * @method outputLogFormatter
  3845   * @param {Object} log object
  3846   * @returns {Object} log
  3847  */
  3848  var outputLogFormatter = function(log) {
  3849      if(log.blockNumber)
  3850          log.blockNumber = utils.toDecimal(log.blockNumber);
  3851      if(log.transactionIndex)
  3852          log.transactionIndex = utils.toDecimal(log.transactionIndex);
  3853      if(log.logIndex)
  3854          log.logIndex = utils.toDecimal(log.logIndex);
  3855  
  3856      return log;
  3857  };
  3858  
  3859  /**
  3860   * Formats the input of a whisper post and converts all values to HEX
  3861   *
  3862   * @method inputPostFormatter
  3863   * @param {Object} transaction object
  3864   * @returns {Object}
  3865  */
  3866  var inputPostFormatter = function(post) {
  3867  
  3868      // post.payload = utils.toHex(post.payload);
  3869      post.ttl = utils.fromDecimal(post.ttl);
  3870      post.workToProve = utils.fromDecimal(post.workToProve);
  3871      post.priority = utils.fromDecimal(post.priority);
  3872  
  3873      // fallback
  3874      if (!utils.isArray(post.topics)) {
  3875          post.topics = post.topics ? [post.topics] : [];
  3876      }
  3877  
  3878      // format the following options
  3879      post.topics = post.topics.map(function(topic){
  3880          // convert only if not hex
  3881          return (topic.indexOf('0x') === 0) ? topic : utils.fromUtf8(topic);
  3882      });
  3883  
  3884      return post;
  3885  };
  3886  
  3887  /**
  3888   * Formats the output of a received post message
  3889   *
  3890   * @method outputPostFormatter
  3891   * @param {Object}
  3892   * @returns {Object}
  3893   */
  3894  var outputPostFormatter = function(post){
  3895  
  3896      post.expiry = utils.toDecimal(post.expiry);
  3897      post.sent = utils.toDecimal(post.sent);
  3898      post.ttl = utils.toDecimal(post.ttl);
  3899      post.workProved = utils.toDecimal(post.workProved);
  3900      // post.payloadRaw = post.payload;
  3901      // post.payload = utils.toAscii(post.payload);
  3902  
  3903      // if (utils.isJson(post.payload)) {
  3904      //     post.payload = JSON.parse(post.payload);
  3905      // }
  3906  
  3907      // format the following options
  3908      if (!post.topics) {
  3909          post.topics = [];
  3910      }
  3911      post.topics = post.topics.map(function(topic){
  3912          return utils.toAscii(topic);
  3913      });
  3914  
  3915      return post;
  3916  };
  3917  
  3918  var inputAddressFormatter = function (address) {
  3919      var iban = new Iban(address);
  3920      if (iban.isValid() && iban.isDirect()) {
  3921          return '0x' + iban.address();
  3922      } else if (utils.isStrictAddress(address)) {
  3923          return address;
  3924      } else if (utils.isAddress(address)) {
  3925          return '0x' + address;
  3926      }
  3927      throw new Error('invalid address');
  3928  };
  3929  
  3930  
  3931  var outputSyncingFormatter = function(result) {
  3932      if (!result) {
  3933          return result;
  3934      }
  3935  
  3936      result.startingBlock = utils.toDecimal(result.startingBlock);
  3937      result.currentBlock = utils.toDecimal(result.currentBlock);
  3938      result.highestBlock = utils.toDecimal(result.highestBlock);
  3939      if (result.knownStates) {
  3940          result.knownStates = utils.toDecimal(result.knownStates);
  3941          result.pulledStates = utils.toDecimal(result.pulledStates);
  3942      }
  3943  
  3944      return result;
  3945  };
  3946  
  3947  module.exports = {
  3948      inputDefaultBlockNumberFormatter: inputDefaultBlockNumberFormatter,
  3949      inputBlockNumberFormatter: inputBlockNumberFormatter,
  3950      inputCallFormatter: inputCallFormatter,
  3951      inputTransactionFormatter: inputTransactionFormatter,
  3952      inputAddressFormatter: inputAddressFormatter,
  3953      inputPostFormatter: inputPostFormatter,
  3954      outputBigNumberFormatter: outputBigNumberFormatter,
  3955      outputTransactionFormatter: outputTransactionFormatter,
  3956      outputTransactionReceiptFormatter: outputTransactionReceiptFormatter,
  3957      outputBlockFormatter: outputBlockFormatter,
  3958      outputLogFormatter: outputLogFormatter,
  3959      outputPostFormatter: outputPostFormatter,
  3960      outputSyncingFormatter: outputSyncingFormatter
  3961  };
  3962  
  3963  
  3964  },{"../utils/config":18,"../utils/utils":20,"./iban":33}],31:[function(require,module,exports){
  3965  /*
  3966      This file is part of web3.js.
  3967  
  3968      web3.js is free software: you can redistribute it and/or modify
  3969      it under the terms of the GNU Lesser General Public License as published by
  3970      the Free Software Foundation, either version 3 of the License, or
  3971      (at your option) any later version.
  3972  
  3973      web3.js is distributed in the hope that it will be useful,
  3974      but WITHOUT ANY WARRANTY; without even the implied warranty of
  3975      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3976      GNU Lesser General Public License for more details.
  3977  
  3978      You should have received a copy of the GNU Lesser General Public License
  3979      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  3980  */
  3981  /**
  3982   * @file function.js
  3983   * @author Marek Kotewicz <marek@ethdev.com>
  3984   * @date 2015
  3985   */
  3986  
  3987  var coder = require('../solidity/coder');
  3988  var utils = require('../utils/utils');
  3989  var errors = require('./errors');
  3990  var formatters = require('./formatters');
  3991  var sha3 = require('../utils/sha3');
  3992  
  3993  /**
  3994   * This prototype should be used to call/sendTransaction to solidity functions
  3995   */
  3996  var SolidityFunction = function (eth, json, address) {
  3997      this._eth = eth;
  3998      this._inputTypes = json.inputs.map(function (i) {
  3999          return i.type;
  4000      });
  4001      this._outputTypes = json.outputs.map(function (i) {
  4002          return i.type;
  4003      });
  4004      this._constant = json.constant;
  4005      this._payable = json.payable;
  4006      this._name = utils.transformToFullName(json);
  4007      this._address = address;
  4008  };
  4009  
  4010  SolidityFunction.prototype.extractCallback = function (args) {
  4011      if (utils.isFunction(args[args.length - 1])) {
  4012          return args.pop(); // modify the args array!
  4013      }
  4014  };
  4015  
  4016  SolidityFunction.prototype.extractDefaultBlock = function (args) {
  4017      if (args.length > this._inputTypes.length && !utils.isObject(args[args.length -1])) {
  4018          return formatters.inputDefaultBlockNumberFormatter(args.pop()); // modify the args array!
  4019      }
  4020  };
  4021  
  4022  /**
  4023   * Should be called to check if the number of arguments is correct
  4024   *
  4025   * @method validateArgs
  4026   * @param {Array} arguments
  4027   * @throws {Error} if it is not
  4028   */
  4029  SolidityFunction.prototype.validateArgs = function (args) {
  4030      var inputArgs = args.filter(function (a) {
  4031        // filter the options object but not arguments that are arrays
  4032        return !( (utils.isObject(a) === true) &&
  4033                  (utils.isArray(a) === false) &&
  4034                  (utils.isBigNumber(a) === false)
  4035                );
  4036      });
  4037      if (inputArgs.length !== this._inputTypes.length) {
  4038          throw errors.InvalidNumberOfSolidityArgs();
  4039      }
  4040  };
  4041  
  4042  /**
  4043   * Should be used to create payload from arguments
  4044   *
  4045   * @method toPayload
  4046   * @param {Array} solidity function params
  4047   * @param {Object} optional payload options
  4048   */
  4049  SolidityFunction.prototype.toPayload = function (args) {
  4050      var options = {};
  4051      if (args.length > this._inputTypes.length && utils.isObject(args[args.length -1])) {
  4052          options = args[args.length - 1];
  4053      }
  4054      this.validateArgs(args);
  4055      options.to = this._address;
  4056      options.data = '0x' + this.signature() + coder.encodeParams(this._inputTypes, args);
  4057      return options;
  4058  };
  4059  
  4060  /**
  4061   * Should be used to get function signature
  4062   *
  4063   * @method signature
  4064   * @return {String} function signature
  4065   */
  4066  SolidityFunction.prototype.signature = function () {
  4067      return sha3(this._name).slice(0, 8);
  4068  };
  4069  
  4070  
  4071  SolidityFunction.prototype.unpackOutput = function (output) {
  4072      if (!output) {
  4073          return;
  4074      }
  4075  
  4076      output = output.length >= 2 ? output.slice(2) : output;
  4077      var result = coder.decodeParams(this._outputTypes, output);
  4078      return result.length === 1 ? result[0] : result;
  4079  };
  4080  
  4081  /**
  4082   * Calls a contract function.
  4083   *
  4084   * @method call
  4085   * @param {...Object} Contract function arguments
  4086   * @param {function} If the last argument is a function, the contract function
  4087   *   call will be asynchronous, and the callback will be passed the
  4088   *   error and result.
  4089   * @return {String} output bytes
  4090   */
  4091  SolidityFunction.prototype.call = function () {
  4092      var args = Array.prototype.slice.call(arguments).filter(function (a) {return a !== undefined; });
  4093      var callback = this.extractCallback(args);
  4094      var defaultBlock = this.extractDefaultBlock(args);
  4095      var payload = this.toPayload(args);
  4096  
  4097  
  4098      if (!callback) {
  4099          var output = this._eth.call(payload, defaultBlock);
  4100          return this.unpackOutput(output);
  4101      }
  4102  
  4103      var self = this;
  4104      this._eth.call(payload, defaultBlock, function (error, output) {
  4105          if (error) return callback(error, null);
  4106  
  4107          var unpacked = null;
  4108          try {
  4109              unpacked = self.unpackOutput(output);
  4110          }
  4111          catch (e) {
  4112              error = e;
  4113          }
  4114  
  4115          callback(error, unpacked);
  4116      });
  4117  };
  4118  
  4119  /**
  4120   * Should be used to sendTransaction to solidity function
  4121   *
  4122   * @method sendTransaction
  4123   */
  4124  SolidityFunction.prototype.sendTransaction = function () {
  4125      var args = Array.prototype.slice.call(arguments).filter(function (a) {return a !== undefined; });
  4126      var callback = this.extractCallback(args);
  4127      var payload = this.toPayload(args);
  4128  
  4129      if (payload.value > 0 && !this._payable) {
  4130          throw new Error('Cannot send value to non-payable function');
  4131      }
  4132  
  4133      if (!callback) {
  4134          return this._eth.sendTransaction(payload);
  4135      }
  4136  
  4137      this._eth.sendTransaction(payload, callback);
  4138  };
  4139  
  4140  /**
  4141   * Should be used to estimateGas of solidity function
  4142   *
  4143   * @method estimateGas
  4144   */
  4145  SolidityFunction.prototype.estimateGas = function () {
  4146      var args = Array.prototype.slice.call(arguments);
  4147      var callback = this.extractCallback(args);
  4148      var payload = this.toPayload(args);
  4149  
  4150      if (!callback) {
  4151          return this._eth.estimateGas(payload);
  4152      }
  4153  
  4154      this._eth.estimateGas(payload, callback);
  4155  };
  4156  
  4157  /**
  4158   * Return the encoded data of the call
  4159   *
  4160   * @method getData
  4161   * @return {String} the encoded data
  4162   */
  4163  SolidityFunction.prototype.getData = function () {
  4164      var args = Array.prototype.slice.call(arguments);
  4165      var payload = this.toPayload(args);
  4166  
  4167      return payload.data;
  4168  };
  4169  
  4170  /**
  4171   * Should be used to get function display name
  4172   *
  4173   * @method displayName
  4174   * @return {String} display name of the function
  4175   */
  4176  SolidityFunction.prototype.displayName = function () {
  4177      return utils.extractDisplayName(this._name);
  4178  };
  4179  
  4180  /**
  4181   * Should be used to get function type name
  4182   *
  4183   * @method typeName
  4184   * @return {String} type name of the function
  4185   */
  4186  SolidityFunction.prototype.typeName = function () {
  4187      return utils.extractTypeName(this._name);
  4188  };
  4189  
  4190  /**
  4191   * Should be called to get rpc requests from solidity function
  4192   *
  4193   * @method request
  4194   * @returns {Object}
  4195   */
  4196  SolidityFunction.prototype.request = function () {
  4197      var args = Array.prototype.slice.call(arguments);
  4198      var callback = this.extractCallback(args);
  4199      var payload = this.toPayload(args);
  4200      var format = this.unpackOutput.bind(this);
  4201  
  4202      return {
  4203          method: this._constant ? 'eth_call' : 'eth_sendTransaction',
  4204          callback: callback,
  4205          params: [payload],
  4206          format: format
  4207      };
  4208  };
  4209  
  4210  /**
  4211   * Should be called to execute function
  4212   *
  4213   * @method execute
  4214   */
  4215  SolidityFunction.prototype.execute = function () {
  4216      var transaction = !this._constant;
  4217  
  4218      // send transaction
  4219      if (transaction) {
  4220          return this.sendTransaction.apply(this, Array.prototype.slice.call(arguments));
  4221      }
  4222  
  4223      // call
  4224      return this.call.apply(this, Array.prototype.slice.call(arguments));
  4225  };
  4226  
  4227  /**
  4228   * Should be called to attach function to contract
  4229   *
  4230   * @method attachToContract
  4231   * @param {Contract}
  4232   */
  4233  SolidityFunction.prototype.attachToContract = function (contract) {
  4234      var execute = this.execute.bind(this);
  4235      execute.request = this.request.bind(this);
  4236      execute.call = this.call.bind(this);
  4237      execute.sendTransaction = this.sendTransaction.bind(this);
  4238      execute.estimateGas = this.estimateGas.bind(this);
  4239      execute.getData = this.getData.bind(this);
  4240      var displayName = this.displayName();
  4241      if (!contract[displayName]) {
  4242          contract[displayName] = execute;
  4243      }
  4244      contract[displayName][this.typeName()] = execute; // circular!!!!
  4245  };
  4246  
  4247  module.exports = SolidityFunction;
  4248  
  4249  },{"../solidity/coder":7,"../utils/sha3":19,"../utils/utils":20,"./errors":26,"./formatters":30}],32:[function(require,module,exports){
  4250  /*
  4251      This file is part of web3.js.
  4252  
  4253      web3.js is free software: you can redistribute it and/or modify
  4254      it under the terms of the GNU Lesser General Public License as published by
  4255      the Free Software Foundation, either version 3 of the License, or
  4256      (at your option) any later version.
  4257  
  4258      web3.js is distributed in the hope that it will be useful,
  4259      but WITHOUT ANY WARRANTY; without even the implied warranty of
  4260      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4261      GNU Lesser General Public License for more details.
  4262  
  4263      You should have received a copy of the GNU Lesser General Public License
  4264      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  4265  */
  4266  /** @file httpprovider.js
  4267   * @authors:
  4268   *   Marek Kotewicz <marek@ethdev.com>
  4269   *   Marian Oancea <marian@ethdev.com>
  4270   *   Fabian Vogelsteller <fabian@ethdev.com>
  4271   * @date 2015
  4272   */
  4273  
  4274  var errors = require('./errors');
  4275  
  4276  // workaround to use httpprovider in different envs
  4277  
  4278  // browser
  4279  if (typeof window !== 'undefined' && window.XMLHttpRequest) {
  4280    XMLHttpRequest = window.XMLHttpRequest; // jshint ignore: line
  4281  // node
  4282  } else {
  4283    XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore: line
  4284  }
  4285  
  4286  var XHR2 = require('xhr2'); // jshint ignore: line
  4287  
  4288  /**
  4289   * HttpProvider should be used to send rpc calls over http
  4290   */
  4291  var HttpProvider = function (host, timeout, user, password) {
  4292    this.host = host || 'http://localhost:8545';
  4293    this.timeout = timeout || 0;
  4294    this.user = user;
  4295    this.password = password;
  4296  };
  4297  
  4298  /**
  4299   * Should be called to prepare new XMLHttpRequest
  4300   *
  4301   * @method prepareRequest
  4302   * @param {Boolean} true if request should be async
  4303   * @return {XMLHttpRequest} object
  4304   */
  4305  HttpProvider.prototype.prepareRequest = function (async) {
  4306    var request;
  4307  
  4308    if (async) {
  4309      request = new XHR2();
  4310      request.timeout = this.timeout;
  4311    } else {
  4312      request = new XMLHttpRequest();
  4313    }
  4314  
  4315    request.open('POST', this.host, async);
  4316    if (this.user && this.password) {
  4317      var auth = 'Basic ' + new Buffer(this.user + ':' + this.password).toString('base64');
  4318      request.setRequestHeader('Authorization', auth);
  4319    } request.setRequestHeader('Content-Type', 'application/json');
  4320    return request;
  4321  };
  4322  
  4323  /**
  4324   * Should be called to make sync request
  4325   *
  4326   * @method send
  4327   * @param {Object} payload
  4328   * @return {Object} result
  4329   */
  4330  HttpProvider.prototype.send = function (payload) {
  4331    var request = this.prepareRequest(false);
  4332  
  4333    try {
  4334      request.send(JSON.stringify(payload));
  4335    } catch (error) {
  4336      throw errors.InvalidConnection(this.host);
  4337    }
  4338  
  4339    var result = request.responseText;
  4340  
  4341    try {
  4342      result = JSON.parse(result);
  4343    } catch (e) {
  4344      throw errors.InvalidResponse(request.responseText);
  4345    }
  4346  
  4347    return result;
  4348  };
  4349  
  4350  /**
  4351   * Should be used to make async request
  4352   *
  4353   * @method sendAsync
  4354   * @param {Object} payload
  4355   * @param {Function} callback triggered on end with (err, result)
  4356   */
  4357  HttpProvider.prototype.sendAsync = function (payload, callback) {
  4358    var request = this.prepareRequest(true);
  4359  
  4360    request.onreadystatechange = function () {
  4361      if (request.readyState === 4 && request.timeout !== 1) {
  4362        var result = request.responseText;
  4363        var error = null;
  4364  
  4365        try {
  4366          result = JSON.parse(result);
  4367        } catch (e) {
  4368          error = errors.InvalidResponse(request.responseText);
  4369        }
  4370  
  4371        callback(error, result);
  4372      }
  4373    };
  4374  
  4375    request.ontimeout = function () {
  4376      callback(errors.ConnectionTimeout(this.timeout));
  4377    };
  4378  
  4379    try {
  4380      request.send(JSON.stringify(payload));
  4381    } catch (error) {
  4382      callback(errors.InvalidConnection(this.host));
  4383    }
  4384  };
  4385  
  4386  /**
  4387   * Synchronously tries to make Http request
  4388   *
  4389   * @method isConnected
  4390   * @return {Boolean} returns true if request haven't failed. Otherwise false
  4391   */
  4392  HttpProvider.prototype.isConnected = function () {
  4393    try {
  4394      this.send({
  4395        id: 9999999999,
  4396        jsonrpc: '2.0',
  4397        method: 'net_listening',
  4398        params: []
  4399      });
  4400      return true;
  4401    } catch (e) {
  4402      return false;
  4403    }
  4404  };
  4405  
  4406  module.exports = HttpProvider;
  4407  
  4408  },{"./errors":26,"xhr2":86,"xmlhttprequest":17}],33:[function(require,module,exports){
  4409  /*
  4410      This file is part of web3.js.
  4411  
  4412      web3.js is free software: you can redistribute it and/or modify
  4413      it under the terms of the GNU Lesser General Public License as published by
  4414      the Free Software Foundation, either version 3 of the License, or
  4415      (at your option) any later version.
  4416  
  4417      web3.js is distributed in the hope that it will be useful,
  4418      but WITHOUT ANY WARRANTY; without even the implied warranty of
  4419      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4420      GNU Lesser General Public License for more details.
  4421  
  4422      You should have received a copy of the GNU Lesser General Public License
  4423      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  4424  */
  4425  /**
  4426   * @file iban.js
  4427   * @author Marek Kotewicz <marek@ethdev.com>
  4428   * @date 2015
  4429   */
  4430  
  4431  var BigNumber = require('bignumber.js');
  4432  
  4433  var padLeft = function (string, bytes) {
  4434      var result = string;
  4435      while (result.length < bytes * 2) {
  4436          result = '0' + result;
  4437      }
  4438      return result;
  4439  };
  4440  
  4441  /**
  4442   * Prepare an IBAN for mod 97 computation by moving the first 4 chars to the end and transforming the letters to
  4443   * numbers (A = 10, B = 11, ..., Z = 35), as specified in ISO13616.
  4444   *
  4445   * @method iso13616Prepare
  4446   * @param {String} iban the IBAN
  4447   * @returns {String} the prepared IBAN
  4448   */
  4449  var iso13616Prepare = function (iban) {
  4450      var A = 'A'.charCodeAt(0);
  4451      var Z = 'Z'.charCodeAt(0);
  4452  
  4453      iban = iban.toUpperCase();
  4454      iban = iban.substr(4) + iban.substr(0,4);
  4455  
  4456      return iban.split('').map(function(n){
  4457          var code = n.charCodeAt(0);
  4458          if (code >= A && code <= Z){
  4459              // A = 10, B = 11, ... Z = 35
  4460              return code - A + 10;
  4461          } else {
  4462              return n;
  4463          }
  4464      }).join('');
  4465  };
  4466  
  4467  /**
  4468   * Calculates the MOD 97 10 of the passed IBAN as specified in ISO7064.
  4469   *
  4470   * @method mod9710
  4471   * @param {String} iban
  4472   * @returns {Number}
  4473   */
  4474  var mod9710 = function (iban) {
  4475      var remainder = iban,
  4476          block;
  4477  
  4478      while (remainder.length > 2){
  4479          block = remainder.slice(0, 9);
  4480          remainder = parseInt(block, 10) % 97 + remainder.slice(block.length);
  4481      }
  4482  
  4483      return parseInt(remainder, 10) % 97;
  4484  };
  4485  
  4486  /**
  4487   * This prototype should be used to create iban object from iban correct string
  4488   *
  4489   * @param {String} iban
  4490   */
  4491  var Iban = function (iban) {
  4492      this._iban = iban;
  4493  };
  4494  
  4495  /**
  4496   * This method should be used to create iban object from ebakus address
  4497   *
  4498   * @method fromAddress
  4499   * @param {String} address
  4500   * @return {Iban} the IBAN object
  4501   */
  4502  Iban.fromAddress = function (address) {
  4503      var asBn = new BigNumber(address, 16);
  4504      var base36 = asBn.toString(36);
  4505      var padded = padLeft(base36, 15);
  4506      return Iban.fromBban(padded.toUpperCase());
  4507  };
  4508  
  4509  /**
  4510   * Convert the passed BBAN to an IBAN for this country specification.
  4511   * Please note that <i>"generation of the IBAN shall be the exclusive responsibility of the bank/branch servicing the account"</i>.
  4512   * This method implements the preferred algorithm described in http://en.wikipedia.org/wiki/International_Bank_Account_Number#Generating_IBAN_check_digits
  4513   *
  4514   * @method fromBban
  4515   * @param {String} bban the BBAN to convert to IBAN
  4516   * @returns {Iban} the IBAN object
  4517   */
  4518  Iban.fromBban = function (bban) {
  4519      var countryCode = 'XE';
  4520  
  4521      var remainder = mod9710(iso13616Prepare(countryCode + '00' + bban));
  4522      var checkDigit = ('0' + (98 - remainder)).slice(-2);
  4523  
  4524      return new Iban(countryCode + checkDigit + bban);
  4525  };
  4526  
  4527  /**
  4528   * Should be used to create IBAN object for given institution and identifier
  4529   *
  4530   * @method createIndirect
  4531   * @param {Object} options, required options are "institution" and "identifier"
  4532   * @return {Iban} the IBAN object
  4533   */
  4534  Iban.createIndirect = function (options) {
  4535      return Iban.fromBban('ETH' + options.institution + options.identifier);
  4536  };
  4537  
  4538  /**
  4539   * Thos method should be used to check if given string is valid iban object
  4540   *
  4541   * @method isValid
  4542   * @param {String} iban string
  4543   * @return {Boolean} true if it is valid IBAN
  4544   */
  4545  Iban.isValid = function (iban) {
  4546      var i = new Iban(iban);
  4547      return i.isValid();
  4548  };
  4549  
  4550  /**
  4551   * Should be called to check if iban is correct
  4552   *
  4553   * @method isValid
  4554   * @returns {Boolean} true if it is, otherwise false
  4555   */
  4556  Iban.prototype.isValid = function () {
  4557      return /^XE[0-9]{2}(ETH[0-9A-Z]{13}|[0-9A-Z]{30,31})$/.test(this._iban) &&
  4558          mod9710(iso13616Prepare(this._iban)) === 1;
  4559  };
  4560  
  4561  /**
  4562   * Should be called to check if iban number is direct
  4563   *
  4564   * @method isDirect
  4565   * @returns {Boolean} true if it is, otherwise false
  4566   */
  4567  Iban.prototype.isDirect = function () {
  4568      return this._iban.length === 34 || this._iban.length === 35;
  4569  };
  4570  
  4571  /**
  4572   * Should be called to check if iban number if indirect
  4573   *
  4574   * @method isIndirect
  4575   * @returns {Boolean} true if it is, otherwise false
  4576   */
  4577  Iban.prototype.isIndirect = function () {
  4578      return this._iban.length === 20;
  4579  };
  4580  
  4581  /**
  4582   * Should be called to get iban checksum
  4583   * Uses the mod-97-10 checksumming protocol (ISO/IEC 7064:2003)
  4584   *
  4585   * @method checksum
  4586   * @returns {String} checksum
  4587   */
  4588  Iban.prototype.checksum = function () {
  4589      return this._iban.substr(2, 2);
  4590  };
  4591  
  4592  /**
  4593   * Should be called to get institution identifier
  4594   * eg. XREG
  4595   *
  4596   * @method institution
  4597   * @returns {String} institution identifier
  4598   */
  4599  Iban.prototype.institution = function () {
  4600      return this.isIndirect() ? this._iban.substr(7, 4) : '';
  4601  };
  4602  
  4603  /**
  4604   * Should be called to get client identifier within institution
  4605   * eg. GAVOFYORK
  4606   *
  4607   * @method client
  4608   * @returns {String} client identifier
  4609   */
  4610  Iban.prototype.client = function () {
  4611      return this.isIndirect() ? this._iban.substr(11) : '';
  4612  };
  4613  
  4614  /**
  4615   * Should be called to get client direct address
  4616   *
  4617   * @method address
  4618   * @returns {String} client direct address
  4619   */
  4620  Iban.prototype.address = function () {
  4621      if (this.isDirect()) {
  4622          var base36 = this._iban.substr(4);
  4623          var asBn = new BigNumber(base36, 36);
  4624          return padLeft(asBn.toString(16), 20);
  4625      }
  4626  
  4627      return '';
  4628  };
  4629  
  4630  Iban.prototype.toString = function () {
  4631      return this._iban;
  4632  };
  4633  
  4634  module.exports = Iban;
  4635  
  4636  
  4637  },{"bignumber.js":"bignumber.js"}],34:[function(require,module,exports){
  4638  /*
  4639      This file is part of web3.js.
  4640  
  4641      web3.js is free software: you can redistribute it and/or modify
  4642      it under the terms of the GNU Lesser General Public License as published by
  4643      the Free Software Foundation, either version 3 of the License, or
  4644      (at your option) any later version.
  4645  
  4646      web3.js is distributed in the hope that it will be useful,
  4647      but WITHOUT ANY WARRANTY; without even the implied warranty of
  4648      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4649      GNU Lesser General Public License for more details.
  4650  
  4651      You should have received a copy of the GNU Lesser General Public License
  4652      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  4653  */
  4654  /** @file ipcprovider.js
  4655   * @authors:
  4656   *   Fabian Vogelsteller <fabian@ethdev.com>
  4657   * @date 2015
  4658   */
  4659  
  4660  "use strict";
  4661  
  4662  var utils = require('../utils/utils');
  4663  var errors = require('./errors');
  4664  
  4665  
  4666  var IpcProvider = function (path, net) {
  4667      var _this = this;
  4668      this.responseCallbacks = {};
  4669      this.path = path;
  4670  
  4671      this.connection = net.connect({path: this.path});
  4672  
  4673      this.connection.on('error', function(e){
  4674          console.error('IPC Connection Error', e);
  4675          _this._timeout();
  4676      });
  4677  
  4678      this.connection.on('end', function(){
  4679          _this._timeout();
  4680      });
  4681  
  4682  
  4683      // LISTEN FOR CONNECTION RESPONSES
  4684      this.connection.on('data', function(data) {
  4685          /*jshint maxcomplexity: 6 */
  4686  
  4687          _this._parseResponse(data.toString()).forEach(function(result){
  4688  
  4689              var id = null;
  4690  
  4691              // get the id which matches the returned id
  4692              if(utils.isArray(result)) {
  4693                  result.forEach(function(load){
  4694                      if(_this.responseCallbacks[load.id])
  4695                          id = load.id;
  4696                  });
  4697              } else {
  4698                  id = result.id;
  4699              }
  4700  
  4701              // fire the callback
  4702              if(_this.responseCallbacks[id]) {
  4703                  _this.responseCallbacks[id](null, result);
  4704                  delete _this.responseCallbacks[id];
  4705              }
  4706          });
  4707      });
  4708  };
  4709  
  4710  /**
  4711  Will parse the response and make an array out of it.
  4712  
  4713  @method _parseResponse
  4714  @param {String} data
  4715  */
  4716  IpcProvider.prototype._parseResponse = function(data) {
  4717      var _this = this,
  4718          returnValues = [];
  4719  
  4720      // DE-CHUNKER
  4721      var dechunkedData = data
  4722          .replace(/\}[\n\r]?\{/g,'}|--|{') // }{
  4723          .replace(/\}\][\n\r]?\[\{/g,'}]|--|[{') // }][{
  4724          .replace(/\}[\n\r]?\[\{/g,'}|--|[{') // }[{
  4725          .replace(/\}\][\n\r]?\{/g,'}]|--|{') // }]{
  4726          .split('|--|');
  4727  
  4728      dechunkedData.forEach(function(data){
  4729  
  4730          // prepend the last chunk
  4731          if(_this.lastChunk)
  4732              data = _this.lastChunk + data;
  4733  
  4734          var result = null;
  4735  
  4736          try {
  4737              result = JSON.parse(data);
  4738  
  4739          } catch(e) {
  4740  
  4741              _this.lastChunk = data;
  4742  
  4743              // start timeout to cancel all requests
  4744              clearTimeout(_this.lastChunkTimeout);
  4745              _this.lastChunkTimeout = setTimeout(function(){
  4746                  _this._timeout();
  4747                  throw errors.InvalidResponse(data);
  4748              }, 1000 * 15);
  4749  
  4750              return;
  4751          }
  4752  
  4753          // cancel timeout and set chunk to null
  4754          clearTimeout(_this.lastChunkTimeout);
  4755          _this.lastChunk = null;
  4756  
  4757          if(result)
  4758              returnValues.push(result);
  4759      });
  4760  
  4761      return returnValues;
  4762  };
  4763  
  4764  
  4765  /**
  4766  Get the adds a callback to the responseCallbacks object,
  4767  which will be called if a response matching the response Id will arrive.
  4768  
  4769  @method _addResponseCallback
  4770  */
  4771  IpcProvider.prototype._addResponseCallback = function(payload, callback) {
  4772      var id = payload.id || payload[0].id;
  4773      var method = payload.method || payload[0].method;
  4774  
  4775      this.responseCallbacks[id] = callback;
  4776      this.responseCallbacks[id].method = method;
  4777  };
  4778  
  4779  /**
  4780  Timeout all requests when the end/error event is fired
  4781  
  4782  @method _timeout
  4783  */
  4784  IpcProvider.prototype._timeout = function() {
  4785      for(var key in this.responseCallbacks) {
  4786          if(this.responseCallbacks.hasOwnProperty(key)){
  4787              this.responseCallbacks[key](errors.InvalidConnection('on IPC'));
  4788              delete this.responseCallbacks[key];
  4789          }
  4790      }
  4791  };
  4792  
  4793  
  4794  /**
  4795  Check if the current connection is still valid.
  4796  
  4797  @method isConnected
  4798  */
  4799  IpcProvider.prototype.isConnected = function() {
  4800      var _this = this;
  4801  
  4802      // try reconnect, when connection is gone
  4803      if(!_this.connection.writable)
  4804          _this.connection.connect({path: _this.path});
  4805  
  4806      return !!this.connection.writable;
  4807  };
  4808  
  4809  IpcProvider.prototype.send = function (payload) {
  4810  
  4811      if(this.connection.writeSync) {
  4812          var result;
  4813  
  4814          // try reconnect, when connection is gone
  4815          if(!this.connection.writable)
  4816              this.connection.connect({path: this.path});
  4817  
  4818          var data = this.connection.writeSync(JSON.stringify(payload));
  4819  
  4820          try {
  4821              result = JSON.parse(data);
  4822          } catch(e) {
  4823              throw errors.InvalidResponse(data);
  4824          }
  4825  
  4826          return result;
  4827  
  4828      } else {
  4829          throw new Error('You tried to send "'+ payload.method +'" synchronously. Synchronous requests are not supported by the IPC provider.');
  4830      }
  4831  };
  4832  
  4833  IpcProvider.prototype.sendAsync = function (payload, callback) {
  4834      // try reconnect, when connection is gone
  4835      if(!this.connection.writable)
  4836          this.connection.connect({path: this.path});
  4837  
  4838  
  4839      this.connection.write(JSON.stringify(payload));
  4840      this._addResponseCallback(payload, callback);
  4841  };
  4842  
  4843  module.exports = IpcProvider;
  4844  
  4845  
  4846  },{"../utils/utils":20,"./errors":26}],35:[function(require,module,exports){
  4847  /*
  4848      This file is part of web3.js.
  4849  
  4850      web3.js is free software: you can redistribute it and/or modify
  4851      it under the terms of the GNU Lesser General Public License as published by
  4852      the Free Software Foundation, either version 3 of the License, or
  4853      (at your option) any later version.
  4854  
  4855      web3.js is distributed in the hope that it will be useful,
  4856      but WITHOUT ANY WARRANTY; without even the implied warranty of
  4857      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4858      GNU Lesser General Public License for more details.
  4859  
  4860      You should have received a copy of the GNU Lesser General Public License
  4861      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  4862  */
  4863  /** @file jsonrpc.js
  4864   * @authors:
  4865   *   Marek Kotewicz <marek@ethdev.com>
  4866   *   Aaron Kumavis <aaron@kumavis.me>
  4867   * @date 2015
  4868   */
  4869  
  4870  // Initialize Jsonrpc as a simple object with utility functions.
  4871  var Jsonrpc = {
  4872      messageId: 0
  4873  };
  4874  
  4875  /**
  4876   * Should be called to valid json create payload object
  4877   *
  4878   * @method toPayload
  4879   * @param {Function} method of jsonrpc call, required
  4880   * @param {Array} params, an array of method params, optional
  4881   * @returns {Object} valid jsonrpc payload object
  4882   */
  4883  Jsonrpc.toPayload = function (method, params) {
  4884      if (!method)
  4885          console.error('jsonrpc method should be specified!');
  4886  
  4887      // advance message ID
  4888      Jsonrpc.messageId++;
  4889  
  4890      return {
  4891          jsonrpc: '2.0',
  4892          id: Jsonrpc.messageId,
  4893          method: method,
  4894          params: params || []
  4895      };
  4896  };
  4897  
  4898  /**
  4899   * Should be called to check if jsonrpc response is valid
  4900   *
  4901   * @method isValidResponse
  4902   * @param {Object}
  4903   * @returns {Boolean} true if response is valid, otherwise false
  4904   */
  4905  Jsonrpc.isValidResponse = function (response) {
  4906      return Array.isArray(response) ? response.every(validateSingleMessage) : validateSingleMessage(response);
  4907  
  4908      function validateSingleMessage(message){
  4909        return !!message &&
  4910          !message.error &&
  4911          message.jsonrpc === '2.0' &&
  4912          typeof message.id === 'number' &&
  4913          message.result !== undefined; // only undefined is not valid json object
  4914      }
  4915  };
  4916  
  4917  /**
  4918   * Should be called to create batch payload object
  4919   *
  4920   * @method toBatchPayload
  4921   * @param {Array} messages, an array of objects with method (required) and params (optional) fields
  4922   * @returns {Array} batch payload
  4923   */
  4924  Jsonrpc.toBatchPayload = function (messages) {
  4925      return messages.map(function (message) {
  4926          return Jsonrpc.toPayload(message.method, message.params);
  4927      });
  4928  };
  4929  
  4930  module.exports = Jsonrpc;
  4931  
  4932  
  4933  },{}],36:[function(require,module,exports){
  4934  /*
  4935      This file is part of web3.js.
  4936  
  4937      web3.js is free software: you can redistribute it and/or modify
  4938      it under the terms of the GNU Lesser General Public License as published by
  4939      the Free Software Foundation, either version 3 of the License, or
  4940      (at your option) any later version.
  4941  
  4942      web3.js is distributed in the hope that it will be useful,
  4943      but WITHOUT ANY WARRANTY; without even the implied warranty of
  4944      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4945      GNU Lesser General Public License for more details.
  4946  
  4947      You should have received a copy of the GNU Lesser General Public License
  4948      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  4949  */
  4950  /**
  4951   * @file method.js
  4952   * @author Marek Kotewicz <marek@ethdev.com>
  4953   * @date 2015
  4954   */
  4955  
  4956  var utils = require('../utils/utils');
  4957  var errors = require('./errors');
  4958  
  4959  var Method = function (options) {
  4960      this.name = options.name;
  4961      this.call = options.call;
  4962      this.params = options.params || 0;
  4963      this.inputFormatter = options.inputFormatter;
  4964      this.outputFormatter = options.outputFormatter;
  4965      this.requestManager = null;
  4966  };
  4967  
  4968  Method.prototype.setRequestManager = function (rm) {
  4969      this.requestManager = rm;
  4970  };
  4971  
  4972  /**
  4973   * Should be used to determine name of the jsonrpc method based on arguments
  4974   *
  4975   * @method getCall
  4976   * @param {Array} arguments
  4977   * @return {String} name of jsonrpc method
  4978   */
  4979  Method.prototype.getCall = function (args) {
  4980      return utils.isFunction(this.call) ? this.call(args) : this.call;
  4981  };
  4982  
  4983  /**
  4984   * Should be used to extract callback from array of arguments. Modifies input param
  4985   *
  4986   * @method extractCallback
  4987   * @param {Array} arguments
  4988   * @return {Function|Null} callback, if exists
  4989   */
  4990  Method.prototype.extractCallback = function (args) {
  4991      if (utils.isFunction(args[args.length - 1])) {
  4992          return args.pop(); // modify the args array!
  4993      }
  4994  };
  4995  
  4996  /**
  4997   * Should be called to check if the number of arguments is correct
  4998   *
  4999   * @method validateArgs
  5000   * @param {Array} arguments
  5001   * @throws {Error} if it is not
  5002   */
  5003  Method.prototype.validateArgs = function (args) {
  5004      if (args.length !== this.params) {
  5005          throw errors.InvalidNumberOfRPCParams();
  5006      }
  5007  };
  5008  
  5009  /**
  5010   * Should be called to format input args of method
  5011   *
  5012   * @method formatInput
  5013   * @param {Array}
  5014   * @return {Array}
  5015   */
  5016  Method.prototype.formatInput = function (args) {
  5017      if (!this.inputFormatter) {
  5018          return args;
  5019      }
  5020  
  5021      return this.inputFormatter.map(function (formatter, index) {
  5022          return formatter ? formatter(args[index]) : args[index];
  5023      });
  5024  };
  5025  
  5026  /**
  5027   * Should be called to format output(result) of method
  5028   *
  5029   * @method formatOutput
  5030   * @param {Object}
  5031   * @return {Object}
  5032   */
  5033  Method.prototype.formatOutput = function (result) {
  5034      return this.outputFormatter && result ? this.outputFormatter(result) : result;
  5035  };
  5036  
  5037  /**
  5038   * Should create payload from given input args
  5039   *
  5040   * @method toPayload
  5041   * @param {Array} args
  5042   * @return {Object}
  5043   */
  5044  Method.prototype.toPayload = function (args) {
  5045      var call = this.getCall(args);
  5046      var callback = this.extractCallback(args);
  5047      var params = this.formatInput(args);
  5048      this.validateArgs(params);
  5049  
  5050      return {
  5051          method: call,
  5052          params: params,
  5053          callback: callback
  5054      };
  5055  };
  5056  
  5057  Method.prototype.attachToObject = function (obj) {
  5058      var func = this.buildCall();
  5059      func.call = this.call; // TODO!!! that's ugly. filter.js uses it
  5060      var name = this.name.split('.');
  5061      if (name.length > 1) {
  5062          obj[name[0]] = obj[name[0]] || {};
  5063          obj[name[0]][name[1]] = func;
  5064      } else {
  5065          obj[name[0]] = func;
  5066      }
  5067  };
  5068  
  5069  Method.prototype.buildCall = function() {
  5070      var method = this;
  5071      var send = function () {
  5072          var payload = method.toPayload(Array.prototype.slice.call(arguments));
  5073          if (payload.callback) {
  5074              return method.requestManager.sendAsync(payload, function (err, result) {
  5075                  payload.callback(err, method.formatOutput(result));
  5076              });
  5077          }
  5078          return method.formatOutput(method.requestManager.send(payload));
  5079      };
  5080      send.request = this.request.bind(this);
  5081      return send;
  5082  };
  5083  
  5084  /**
  5085   * Should be called to create pure JSONRPC request which can be used in batch request
  5086   *
  5087   * @method request
  5088   * @param {...} params
  5089   * @return {Object} jsonrpc request
  5090   */
  5091  Method.prototype.request = function () {
  5092      var payload = this.toPayload(Array.prototype.slice.call(arguments));
  5093      payload.format = this.formatOutput.bind(this);
  5094      return payload;
  5095  };
  5096  
  5097  module.exports = Method;
  5098  
  5099  },{"../utils/utils":20,"./errors":26}],37:[function(require,module,exports){
  5100  /*
  5101      This file is part of web3.js.
  5102  
  5103      web3.js is free software: you can redistribute it and/or modify
  5104      it under the terms of the GNU Lesser General Public License as published by
  5105      the Free Software Foundation, either version 3 of the License, or
  5106      (at your option) any later version.
  5107  
  5108      web3.js is distributed in the hope that it will be useful,
  5109      but WITHOUT ANY WARRANTY; without even the implied warranty of
  5110      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5111      GNU Lesser General Public License for more details.
  5112  
  5113      You should have received a copy of the GNU Lesser General Public License
  5114      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  5115  */
  5116  /** @file db.js
  5117   * @authors:
  5118   *   Marek Kotewicz <marek@ethdev.com>
  5119   * @date 2015
  5120   */
  5121  
  5122  var Method = require('../method');
  5123  
  5124  var DB = function (web3) {
  5125      this._requestManager = web3._requestManager;
  5126  
  5127      var self = this;
  5128  
  5129      methods().forEach(function(method) {
  5130          method.attachToObject(self);
  5131          method.setRequestManager(web3._requestManager);
  5132      });
  5133  };
  5134  
  5135  var methods = function () {
  5136      var putString = new Method({
  5137          name: 'putString',
  5138          call: 'db_putString',
  5139          params: 3
  5140      });
  5141  
  5142      var getString = new Method({
  5143          name: 'getString',
  5144          call: 'db_getString',
  5145          params: 2
  5146      });
  5147  
  5148      var putHex = new Method({
  5149          name: 'putHex',
  5150          call: 'db_putHex',
  5151          params: 3
  5152      });
  5153  
  5154      var getHex = new Method({
  5155          name: 'getHex',
  5156          call: 'db_getHex',
  5157          params: 2
  5158      });
  5159  
  5160      return [
  5161          putString, getString, putHex, getHex
  5162      ];
  5163  };
  5164  
  5165  module.exports = DB;
  5166  
  5167  },{"../method":36}],38:[function(require,module,exports){
  5168  /*
  5169      This file is part of web3.js.
  5170  
  5171      web3.js is free software: you can redistribute it and/or modify
  5172      it under the terms of the GNU Lesser General Public License as published by
  5173      the Free Software Foundation, either version 3 of the License, or
  5174      (at your option) any later version.
  5175  
  5176      web3.js is distributed in the hope that it will be useful,
  5177      but WITHOUT ANY WARRANTY; without even the implied warranty of
  5178      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5179      GNU Lesser General Public License for more details.
  5180  
  5181      You should have received a copy of the GNU Lesser General Public License
  5182      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  5183  */
  5184  /**
  5185   * @file eth.js
  5186   * @author Marek Kotewicz <marek@ethdev.com>
  5187   * @author Fabian Vogelsteller <fabian@ethdev.com>
  5188   * @date 2015
  5189   */
  5190  
  5191  "use strict";
  5192  
  5193  var formatters = require('../formatters');
  5194  var utils = require('../../utils/utils');
  5195  var Method = require('../method');
  5196  var Property = require('../property');
  5197  var c = require('../../utils/config');
  5198  var Contract = require('../contract');
  5199  var watches = require('./watches');
  5200  var Filter = require('../filter');
  5201  var IsSyncing = require('../syncing');
  5202  var namereg = require('../namereg');
  5203  var Iban = require('../iban');
  5204  var transfer = require('../transfer');
  5205  
  5206  var blockCall = function (args) {
  5207      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? "eth_getBlockByHash" : "eth_getBlockByNumber";
  5208  };
  5209  
  5210  var transactionFromBlockCall = function (args) {
  5211      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getTransactionByBlockHashAndIndex' : 'eth_getTransactionByBlockNumberAndIndex';
  5212  };
  5213  
  5214  var uncleCall = function (args) {
  5215      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleByBlockHashAndIndex' : 'eth_getUncleByBlockNumberAndIndex';
  5216  };
  5217  
  5218  var getBlockTransactionCountCall = function (args) {
  5219      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getBlockTransactionCountByHash' : 'eth_getBlockTransactionCountByNumber';
  5220  };
  5221  
  5222  var uncleCountCall = function (args) {
  5223      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleCountByBlockHash' : 'eth_getUncleCountByBlockNumber';
  5224  };
  5225  
  5226  function Eth(web3) {
  5227      this._requestManager = web3._requestManager;
  5228  
  5229      var self = this;
  5230  
  5231      methods().forEach(function(method) {
  5232          method.attachToObject(self);
  5233          method.setRequestManager(self._requestManager);
  5234      });
  5235  
  5236      properties().forEach(function(p) {
  5237          p.attachToObject(self);
  5238          p.setRequestManager(self._requestManager);
  5239      });
  5240  
  5241  
  5242      this.iban = Iban;
  5243      this.sendIBANTransaction = transfer.bind(null, this);
  5244  }
  5245  
  5246  Object.defineProperty(Eth.prototype, 'defaultBlock', {
  5247      get: function () {
  5248          return c.defaultBlock;
  5249      },
  5250      set: function (val) {
  5251          c.defaultBlock = val;
  5252          return val;
  5253      }
  5254  });
  5255  
  5256  Object.defineProperty(Eth.prototype, 'defaultAccount', {
  5257      get: function () {
  5258          return c.defaultAccount;
  5259      },
  5260      set: function (val) {
  5261          c.defaultAccount = val;
  5262          return val;
  5263      }
  5264  });
  5265  
  5266  var methods = function () {
  5267      var getBalance = new Method({
  5268          name: 'getBalance',
  5269          call: 'eth_getBalance',
  5270          params: 2,
  5271          inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter],
  5272          outputFormatter: formatters.outputBigNumberFormatter
  5273      });
  5274  
  5275      var getVirtualDifficultyFactor = new Method({
  5276          name: 'getVirtualDifficultyFactor',
  5277          call: 'eth_getVirtualDifficultyFactor',
  5278          params: 2,
  5279          inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter],
  5280          outputFormatter: utils.toDecimal
  5281      });
  5282  
  5283      var getDelegates = new Method({
  5284          name: 'getDelegates',
  5285          call: 'dpos_getDelegates',
  5286          params: 1,
  5287          inputFormatter: [formatters.inputDefaultBlockNumberFormatter]
  5288      });
  5289  
  5290      var getStorageAt = new Method({
  5291          name: 'getStorageAt',
  5292          call: 'eth_getStorageAt',
  5293          params: 3,
  5294          inputFormatter: [null, utils.toHex, formatters.inputDefaultBlockNumberFormatter]
  5295      });
  5296  
  5297      var getCode = new Method({
  5298          name: 'getCode',
  5299          call: 'eth_getCode',
  5300          params: 2,
  5301          inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter]
  5302      });
  5303  
  5304      var getBlock = new Method({
  5305          name: 'getBlock',
  5306          call: blockCall,
  5307          params: 2,
  5308          inputFormatter: [formatters.inputBlockNumberFormatter, function (val) { return !!val; }],
  5309          outputFormatter: formatters.outputBlockFormatter
  5310      });
  5311  
  5312      var getUncle = new Method({
  5313          name: 'getUncle',
  5314          call: uncleCall,
  5315          params: 2,
  5316          inputFormatter: [formatters.inputBlockNumberFormatter, utils.toHex],
  5317          outputFormatter: formatters.outputBlockFormatter,
  5318  
  5319      });
  5320  
  5321      var getCompilers = new Method({
  5322          name: 'getCompilers',
  5323          call: 'eth_getCompilers',
  5324          params: 0
  5325      });
  5326  
  5327      var getBlockTransactionCount = new Method({
  5328          name: 'getBlockTransactionCount',
  5329          call: getBlockTransactionCountCall,
  5330          params: 1,
  5331          inputFormatter: [formatters.inputBlockNumberFormatter],
  5332          outputFormatter: utils.toDecimal
  5333      });
  5334  
  5335      var getBlockUncleCount = new Method({
  5336          name: 'getBlockUncleCount',
  5337          call: uncleCountCall,
  5338          params: 1,
  5339          inputFormatter: [formatters.inputBlockNumberFormatter],
  5340          outputFormatter: utils.toDecimal
  5341      });
  5342  
  5343      var getTransaction = new Method({
  5344          name: 'getTransaction',
  5345          call: 'eth_getTransactionByHash',
  5346          params: 1,
  5347          outputFormatter: formatters.outputTransactionFormatter
  5348      });
  5349  
  5350      var getTransactionFromBlock = new Method({
  5351          name: 'getTransactionFromBlock',
  5352          call: transactionFromBlockCall,
  5353          params: 2,
  5354          inputFormatter: [formatters.inputBlockNumberFormatter, utils.toHex],
  5355          outputFormatter: formatters.outputTransactionFormatter
  5356      });
  5357  
  5358      var getTransactionReceipt = new Method({
  5359          name: 'getTransactionReceipt',
  5360          call: 'eth_getTransactionReceipt',
  5361          params: 1,
  5362          outputFormatter: formatters.outputTransactionReceiptFormatter
  5363      });
  5364  
  5365      var getTransactionCount = new Method({
  5366          name: 'getTransactionCount',
  5367          call: 'eth_getTransactionCount',
  5368          params: 2,
  5369          inputFormatter: [null, formatters.inputDefaultBlockNumberFormatter],
  5370          outputFormatter: utils.toDecimal
  5371      });
  5372  
  5373      var sendRawTransaction = new Method({
  5374          name: 'sendRawTransaction',
  5375          call: 'eth_sendRawTransaction',
  5376          params: 1,
  5377          inputFormatter: [null]
  5378      });
  5379  
  5380      var sendTransaction = new Method({
  5381          name: 'sendTransaction',
  5382          call: 'eth_sendTransaction',
  5383          params: 1,
  5384          inputFormatter: [formatters.inputTransactionFormatter]
  5385      });
  5386  
  5387      var signTransaction = new Method({
  5388          name: 'signTransaction',
  5389          call: 'eth_signTransaction',
  5390          params: 1,
  5391          inputFormatter: [formatters.inputTransactionFormatter]
  5392      });
  5393  
  5394      var sign = new Method({
  5395          name: 'sign',
  5396          call: 'eth_sign',
  5397          params: 2,
  5398          inputFormatter: [formatters.inputAddressFormatter, null]
  5399      });
  5400  
  5401      var call = new Method({
  5402          name: 'call',
  5403          call: 'eth_call',
  5404          params: 2,
  5405          inputFormatter: [formatters.inputCallFormatter, formatters.inputDefaultBlockNumberFormatter]
  5406      });
  5407  
  5408      var estimateGas = new Method({
  5409          name: 'estimateGas',
  5410          call: 'eth_estimateGas',
  5411          params: 1,
  5412          inputFormatter: [formatters.inputCallFormatter],
  5413          outputFormatter: utils.toDecimal
  5414      });
  5415  
  5416      var compileSolidity = new Method({
  5417          name: 'compile.solidity',
  5418          call: 'eth_compileSolidity',
  5419          params: 1
  5420      });
  5421  
  5422      var compileLLL = new Method({
  5423          name: 'compile.lll',
  5424          call: 'eth_compileLLL',
  5425          params: 1
  5426      });
  5427  
  5428      var compileSerpent = new Method({
  5429          name: 'compile.serpent',
  5430          call: 'eth_compileSerpent',
  5431          params: 1
  5432      });
  5433  
  5434      var submitWork = new Method({
  5435          name: 'submitWork',
  5436          call: 'eth_submitWork',
  5437          params: 3
  5438      });
  5439  
  5440      var getWork = new Method({
  5441          name: 'getWork',
  5442          call: 'eth_getWork',
  5443          params: 0
  5444      });
  5445  
  5446      return [
  5447          getBalance,
  5448          getVirtualDifficultyFactor,
  5449          getDelegates,
  5450          getStorageAt,
  5451          getCode,
  5452          getBlock,
  5453          getUncle,
  5454          getCompilers,
  5455          getBlockTransactionCount,
  5456          getBlockUncleCount,
  5457          getTransaction,
  5458          getTransactionFromBlock,
  5459          getTransactionReceipt,
  5460          getTransactionCount,
  5461          call,
  5462          estimateGas,
  5463          sendRawTransaction,
  5464          signTransaction,
  5465          sendTransaction,
  5466          sign,
  5467          compileSolidity,
  5468          compileLLL,
  5469          compileSerpent,
  5470          submitWork,
  5471          getWork
  5472      ];
  5473  };
  5474  
  5475  
  5476  var properties = function () {
  5477      return [
  5478          new Property({
  5479              name: 'coinbase',
  5480              getter: 'eth_coinbase'
  5481          }),
  5482          new Property({
  5483              name: 'mining',
  5484              getter: 'eth_mining'
  5485          }),
  5486          new Property({
  5487              name: 'hashrate',
  5488              getter: 'eth_hashrate',
  5489              outputFormatter: utils.toDecimal
  5490          }),
  5491          new Property({
  5492              name: 'syncing',
  5493              getter: 'eth_syncing',
  5494              outputFormatter: formatters.outputSyncingFormatter
  5495          }),
  5496          new Property({
  5497              name: 'gasPrice',
  5498              getter: 'eth_gasPrice',
  5499              outputFormatter: formatters.outputBigNumberFormatter
  5500          }),
  5501          new Property({
  5502              name: 'accounts',
  5503              getter: 'eth_accounts'
  5504          }),
  5505          new Property({
  5506              name: 'blockNumber',
  5507              getter: 'eth_blockNumber',
  5508              outputFormatter: utils.toDecimal
  5509          }),
  5510          new Property({
  5511              name: 'protocolVersion',
  5512              getter: 'eth_protocolVersion'
  5513          })
  5514      ];
  5515  };
  5516  
  5517  Eth.prototype.contract = function (abi) {
  5518      var factory = new Contract(this, abi);
  5519      return factory;
  5520  };
  5521  
  5522  Eth.prototype.filter = function (options, callback, filterCreationErrorCallback) {
  5523      return new Filter(options, 'eth', this._requestManager, watches.eth(), formatters.outputLogFormatter, callback, filterCreationErrorCallback);
  5524  };
  5525  
  5526  Eth.prototype.namereg = function () {
  5527      return this.contract(namereg.global.abi).at(namereg.global.address);
  5528  };
  5529  
  5530  Eth.prototype.icapNamereg = function () {
  5531      return this.contract(namereg.icap.abi).at(namereg.icap.address);
  5532  };
  5533  
  5534  Eth.prototype.isSyncing = function (callback) {
  5535      return new IsSyncing(this._requestManager, callback);
  5536  };
  5537  
  5538  module.exports = Eth;
  5539  
  5540  },{"../../utils/config":18,"../../utils/utils":20,"../contract":25,"../filter":29,"../formatters":30,"../iban":33,"../method":36,"../namereg":44,"../property":45,"../syncing":48,"../transfer":49,"./watches":43}],39:[function(require,module,exports){
  5541  /*
  5542      This file is part of web3.js.
  5543  
  5544      web3.js is free software: you can redistribute it and/or modify
  5545      it under the terms of the GNU Lesser General Public License as published by
  5546      the Free Software Foundation, either version 3 of the License, or
  5547      (at your option) any later version.
  5548  
  5549      web3.js is distributed in the hope that it will be useful,
  5550      but WITHOUT ANY WARRANTY; without even the implied warranty of
  5551      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5552      GNU Lesser General Public License for more details.
  5553  
  5554      You should have received a copy of the GNU Lesser General Public License
  5555      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  5556  */
  5557  /** @file eth.js
  5558   * @authors:
  5559   *   Marek Kotewicz <marek@ethdev.com>
  5560   * @date 2015
  5561   */
  5562  
  5563  var utils = require('../../utils/utils');
  5564  var Property = require('../property');
  5565  
  5566  var Net = function (web3) {
  5567      this._requestManager = web3._requestManager;
  5568  
  5569      var self = this;
  5570  
  5571      properties().forEach(function(p) {
  5572          p.attachToObject(self);
  5573          p.setRequestManager(web3._requestManager);
  5574      });
  5575  };
  5576  
  5577  /// @returns an array of objects describing web3.eth api properties
  5578  var properties = function () {
  5579      return [
  5580          new Property({
  5581              name: 'listening',
  5582              getter: 'net_listening'
  5583          }),
  5584          new Property({
  5585              name: 'peerCount',
  5586              getter: 'net_peerCount',
  5587              outputFormatter: utils.toDecimal
  5588          })
  5589      ];
  5590  };
  5591  
  5592  module.exports = Net;
  5593  
  5594  },{"../../utils/utils":20,"../property":45}],40:[function(require,module,exports){
  5595  /*
  5596      This file is part of web3.js.
  5597  
  5598      web3.js is free software: you can redistribute it and/or modify
  5599      it under the terms of the GNU Lesser General Public License as published by
  5600      the Free Software Foundation, either version 3 of the License, or
  5601      (at your option) any later version.
  5602  
  5603      web3.js is distributed in the hope that it will be useful,
  5604      but WITHOUT ANY WARRANTY; without even the implied warranty of
  5605      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5606      GNU Lesser General Public License for more details.
  5607  
  5608      You should have received a copy of the GNU Lesser General Public License
  5609      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  5610  */
  5611  /**
  5612   * @file eth.js
  5613   * @author Marek Kotewicz <marek@ethdev.com>
  5614   * @author Fabian Vogelsteller <fabian@ethdev.com>
  5615   * @date 2015
  5616   */
  5617  
  5618  "use strict";
  5619  
  5620  var Method = require('../method');
  5621  var Property = require('../property');
  5622  var formatters = require('../formatters');
  5623  
  5624  function Personal(web3) {
  5625      this._requestManager = web3._requestManager;
  5626  
  5627      var self = this;
  5628  
  5629      methods().forEach(function(method) {
  5630          method.attachToObject(self);
  5631          method.setRequestManager(self._requestManager);
  5632      });
  5633  
  5634      properties().forEach(function(p) {
  5635          p.attachToObject(self);
  5636          p.setRequestManager(self._requestManager);
  5637      });
  5638  }
  5639  
  5640  var methods = function () {
  5641      var newAccount = new Method({
  5642          name: 'newAccount',
  5643          call: 'personal_newAccount',
  5644          params: 1,
  5645          inputFormatter: [null]
  5646      });
  5647  
  5648      var importRawKey = new Method({
  5649          name: 'importRawKey',
  5650  		call: 'personal_importRawKey',
  5651  		params: 2
  5652      });
  5653  
  5654      var sign = new Method({
  5655          name: 'sign',
  5656  		call: 'personal_sign',
  5657  		params: 3,
  5658  		inputFormatter: [null, formatters.inputAddressFormatter, null]
  5659      });
  5660  
  5661      var ecRecover = new Method({
  5662          name: 'ecRecover',
  5663  		call: 'personal_ecRecover',
  5664  		params: 2
  5665      });
  5666  
  5667      var unlockAccount = new Method({
  5668          name: 'unlockAccount',
  5669          call: 'personal_unlockAccount',
  5670          params: 3,
  5671          inputFormatter: [formatters.inputAddressFormatter, null, null]
  5672      });
  5673  
  5674      var sendTransaction = new Method({
  5675          name: 'sendTransaction',
  5676          call: 'personal_sendTransaction',
  5677          params: 2,
  5678          inputFormatter: [formatters.inputTransactionFormatter, null]
  5679      });
  5680  
  5681      var lockAccount = new Method({
  5682          name: 'lockAccount',
  5683          call: 'personal_lockAccount',
  5684          params: 1,
  5685          inputFormatter: [formatters.inputAddressFormatter]
  5686      });
  5687  
  5688      return [
  5689          newAccount,
  5690          importRawKey,
  5691          unlockAccount,
  5692          ecRecover,
  5693          sign,
  5694          sendTransaction,
  5695          lockAccount
  5696      ];
  5697  };
  5698  
  5699  var properties = function () {
  5700      return [
  5701          new Property({
  5702              name: 'listAccounts',
  5703              getter: 'personal_listAccounts'
  5704          })
  5705      ];
  5706  };
  5707  
  5708  
  5709  module.exports = Personal;
  5710  
  5711  },{"../formatters":30,"../method":36,"../property":45}],41:[function(require,module,exports){
  5712  /*
  5713      This file is part of web3.js.
  5714  
  5715      web3.js is free software: you can redistribute it and/or modify
  5716      it under the terms of the GNU Lesser General Public License as published by
  5717      the Free Software Foundation, either version 3 of the License, or
  5718      (at your option) any later version.
  5719  
  5720      web3.js is distributed in the hope that it will be useful,
  5721      but WITHOUT ANY WARRANTY; without even the implied warranty of
  5722      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5723      GNU Lesser General Public License for more details.
  5724  
  5725      You should have received a copy of the GNU Lesser General Public License
  5726      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  5727  */
  5728  /** @file shh.js
  5729   * @authors:
  5730   *   Fabian Vogelsteller <fabian@ethereum.org>
  5731   *   Marek Kotewicz <marek@ethcore.io>
  5732   * @date 2017
  5733   */
  5734  
  5735  var Method = require('../method');
  5736  var Filter = require('../filter');
  5737  var watches = require('./watches');
  5738  
  5739  var Shh = function (web3) {
  5740      this._requestManager = web3._requestManager;
  5741  
  5742      var self = this;
  5743  
  5744      methods().forEach(function(method) {
  5745          method.attachToObject(self);
  5746          method.setRequestManager(self._requestManager);
  5747      });
  5748  };
  5749  
  5750  Shh.prototype.newMessageFilter = function (options, callback, filterCreationErrorCallback) {
  5751      return new Filter(options, 'shh', this._requestManager, watches.shh(), null, callback, filterCreationErrorCallback);
  5752  };
  5753  
  5754  var methods = function () {
  5755  
  5756      return [
  5757          new Method({
  5758              name: 'version',
  5759              call: 'shh_version',
  5760              params: 0
  5761          }),
  5762          new Method({
  5763              name: 'info',
  5764              call: 'shh_info',
  5765              params: 0
  5766          }),
  5767          new Method({
  5768              name: 'setMaxMessageSize',
  5769              call: 'shh_setMaxMessageSize',
  5770              params: 1
  5771          }),
  5772          new Method({
  5773              name: 'setMinPoW',
  5774              call: 'shh_setMinPoW',
  5775              params: 1
  5776          }),
  5777          new Method({
  5778              name: 'markTrustedPeer',
  5779              call: 'shh_markTrustedPeer',
  5780              params: 1
  5781          }),
  5782          new Method({
  5783              name: 'newKeyPair',
  5784              call: 'shh_newKeyPair',
  5785              params: 0
  5786          }),
  5787          new Method({
  5788              name: 'addPrivateKey',
  5789              call: 'shh_addPrivateKey',
  5790              params: 1
  5791          }),
  5792          new Method({
  5793              name: 'deleteKeyPair',
  5794              call: 'shh_deleteKeyPair',
  5795              params: 1
  5796          }),
  5797          new Method({
  5798              name: 'hasKeyPair',
  5799              call: 'shh_hasKeyPair',
  5800              params: 1
  5801          }),
  5802          new Method({
  5803              name: 'getPublicKey',
  5804              call: 'shh_getPublicKey',
  5805              params: 1
  5806          }),
  5807          new Method({
  5808              name: 'getPrivateKey',
  5809              call: 'shh_getPrivateKey',
  5810              params: 1
  5811          }),
  5812          new Method({
  5813              name: 'newSymKey',
  5814              call: 'shh_newSymKey',
  5815              params: 0
  5816          }),
  5817          new Method({
  5818              name: 'addSymKey',
  5819              call: 'shh_addSymKey',
  5820              params: 1
  5821          }),
  5822          new Method({
  5823              name: 'generateSymKeyFromPassword',
  5824              call: 'shh_generateSymKeyFromPassword',
  5825              params: 1
  5826          }),
  5827          new Method({
  5828              name: 'hasSymKey',
  5829              call: 'shh_hasSymKey',
  5830              params: 1
  5831          }),
  5832          new Method({
  5833              name: 'getSymKey',
  5834              call: 'shh_getSymKey',
  5835              params: 1
  5836          }),
  5837          new Method({
  5838              name: 'deleteSymKey',
  5839              call: 'shh_deleteSymKey',
  5840              params: 1
  5841          }),
  5842  
  5843          // subscribe and unsubscribe missing
  5844  
  5845          new Method({
  5846              name: 'post',
  5847              call: 'shh_post',
  5848              params: 1,
  5849              inputFormatter: [null]
  5850          })
  5851      ];
  5852  };
  5853  
  5854  module.exports = Shh;
  5855  
  5856  
  5857  },{"../filter":29,"../method":36,"./watches":43}],42:[function(require,module,exports){
  5858  /*
  5859      This file is part of web3.js.
  5860  
  5861      web3.js is free software: you can redistribute it and/or modify
  5862      it under the terms of the GNU Lesser General Public License as published by
  5863      the Free Software Foundation, either version 3 of the License, or
  5864      (at your option) any later version.
  5865  
  5866      web3.js is distributed in the hope that it will be useful,
  5867      but WITHOUT ANY WARRANTY; without even the implied warranty of
  5868      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5869      GNU Lesser General Public License for more details.
  5870  
  5871      You should have received a copy of the GNU Lesser General Public License
  5872      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  5873  */
  5874  /**
  5875   * @file bzz.js
  5876   * @author Alex Beregszaszi <alex@rtfs.hu>
  5877   * @date 2016
  5878   *
  5879   * Reference: https://github.com/ebakus/go-ebakus/blob/swarm/internal/web3ext/web3ext.go#L33
  5880   */
  5881  
  5882  "use strict";
  5883  
  5884  var Method = require('../method');
  5885  var Property = require('../property');
  5886  
  5887  function Swarm(web3) {
  5888      this._requestManager = web3._requestManager;
  5889  
  5890      var self = this;
  5891  
  5892      methods().forEach(function(method) {
  5893          method.attachToObject(self);
  5894          method.setRequestManager(self._requestManager);
  5895      });
  5896  
  5897      properties().forEach(function(p) {
  5898          p.attachToObject(self);
  5899          p.setRequestManager(self._requestManager);
  5900      });
  5901  }
  5902  
  5903  var methods = function () {
  5904      var blockNetworkRead = new Method({
  5905          name: 'blockNetworkRead',
  5906          call: 'bzz_blockNetworkRead',
  5907          params: 1,
  5908          inputFormatter: [null]
  5909      });
  5910  
  5911      var syncEnabled = new Method({
  5912          name: 'syncEnabled',
  5913          call: 'bzz_syncEnabled',
  5914          params: 1,
  5915          inputFormatter: [null]
  5916      });
  5917  
  5918      var swapEnabled = new Method({
  5919          name: 'swapEnabled',
  5920          call: 'bzz_swapEnabled',
  5921          params: 1,
  5922          inputFormatter: [null]
  5923      });
  5924  
  5925      var download = new Method({
  5926          name: 'download',
  5927          call: 'bzz_download',
  5928          params: 2,
  5929          inputFormatter: [null, null]
  5930      });
  5931  
  5932      var upload = new Method({
  5933          name: 'upload',
  5934          call: 'bzz_upload',
  5935          params: 2,
  5936          inputFormatter: [null, null]
  5937      });
  5938  
  5939      var retrieve = new Method({
  5940          name: 'retrieve',
  5941          call: 'bzz_retrieve',
  5942          params: 1,
  5943          inputFormatter: [null]
  5944      });
  5945  
  5946      var store = new Method({
  5947          name: 'store',
  5948          call: 'bzz_store',
  5949          params: 2,
  5950          inputFormatter: [null, null]
  5951      });
  5952  
  5953      var get = new Method({
  5954          name: 'get',
  5955          call: 'bzz_get',
  5956          params: 1,
  5957          inputFormatter: [null]
  5958      });
  5959  
  5960      var put = new Method({
  5961          name: 'put',
  5962          call: 'bzz_put',
  5963          params: 2,
  5964          inputFormatter: [null, null]
  5965      });
  5966  
  5967      var modify = new Method({
  5968          name: 'modify',
  5969          call: 'bzz_modify',
  5970          params: 4,
  5971          inputFormatter: [null, null, null, null]
  5972      });
  5973  
  5974      return [
  5975          blockNetworkRead,
  5976          syncEnabled,
  5977          swapEnabled,
  5978          download,
  5979          upload,
  5980          retrieve,
  5981          store,
  5982          get,
  5983          put,
  5984          modify
  5985      ];
  5986  };
  5987  
  5988  var properties = function () {
  5989      return [
  5990          new Property({
  5991              name: 'hive',
  5992              getter: 'bzz_hive'
  5993          }),
  5994          new Property({
  5995              name: 'info',
  5996              getter: 'bzz_info'
  5997          })
  5998      ];
  5999  };
  6000  
  6001  
  6002  module.exports = Swarm;
  6003  
  6004  },{"../method":36,"../property":45}],43:[function(require,module,exports){
  6005  /*
  6006      This file is part of web3.js.
  6007  
  6008      web3.js is free software: you can redistribute it and/or modify
  6009      it under the terms of the GNU Lesser General Public License as published by
  6010      the Free Software Foundation, either version 3 of the License, or
  6011      (at your option) any later version.
  6012  
  6013      web3.js is distributed in the hope that it will be useful,
  6014      but WITHOUT ANY WARRANTY; without even the implied warranty of
  6015      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  6016      GNU Lesser General Public License for more details.
  6017  
  6018      You should have received a copy of the GNU Lesser General Public License
  6019      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  6020  */
  6021  /** @file watches.js
  6022   * @authors:
  6023   *   Marek Kotewicz <marek@ethdev.com>
  6024   * @date 2015
  6025   */
  6026  
  6027  var Method = require('../method');
  6028  
  6029  /// @returns an array of objects describing web3.eth.filter api methods
  6030  var eth = function () {
  6031      var newFilterCall = function (args) {
  6032          var type = args[0];
  6033  
  6034          switch(type) {
  6035              case 'latest':
  6036                  args.shift();
  6037                  this.params = 0;
  6038                  return 'eth_newBlockFilter';
  6039              case 'pending':
  6040                  args.shift();
  6041                  this.params = 0;
  6042                  return 'eth_newPendingTransactionFilter';
  6043              default:
  6044                  return 'eth_newFilter';
  6045          }
  6046      };
  6047  
  6048      var newFilter = new Method({
  6049          name: 'newFilter',
  6050          call: newFilterCall,
  6051          params: 1
  6052      });
  6053  
  6054      var uninstallFilter = new Method({
  6055          name: 'uninstallFilter',
  6056          call: 'eth_uninstallFilter',
  6057          params: 1
  6058      });
  6059  
  6060      var getLogs = new Method({
  6061          name: 'getLogs',
  6062          call: 'eth_getFilterLogs',
  6063          params: 1
  6064      });
  6065  
  6066      var poll = new Method({
  6067          name: 'poll',
  6068          call: 'eth_getFilterChanges',
  6069          params: 1
  6070      });
  6071  
  6072      return [
  6073          newFilter,
  6074          uninstallFilter,
  6075          getLogs,
  6076          poll
  6077      ];
  6078  };
  6079  
  6080  /// @returns an array of objects describing web3.shh.watch api methods
  6081  var shh = function () {
  6082  
  6083      return [
  6084          new Method({
  6085              name: 'newFilter',
  6086              call: 'shh_newMessageFilter',
  6087              params: 1
  6088          }),
  6089          new Method({
  6090              name: 'uninstallFilter',
  6091              call: 'shh_deleteMessageFilter',
  6092              params: 1
  6093          }),
  6094          new Method({
  6095              name: 'getLogs',
  6096              call: 'shh_getFilterMessages',
  6097              params: 1
  6098          }),
  6099          new Method({
  6100              name: 'poll',
  6101              call: 'shh_getFilterMessages',
  6102              params: 1
  6103          })
  6104      ];
  6105  };
  6106  
  6107  module.exports = {
  6108      eth: eth,
  6109      shh: shh
  6110  };
  6111  
  6112  
  6113  },{"../method":36}],44:[function(require,module,exports){
  6114  /*
  6115      This file is part of web3.js.
  6116  
  6117      web3.js is free software: you can redistribute it and/or modify
  6118      it under the terms of the GNU Lesser General Public License as published by
  6119      the Free Software Foundation, either version 3 of the License, or
  6120      (at your option) any later version.
  6121  
  6122      web3.js is distributed in the hope that it will be useful,
  6123      but WITHOUT ANY WARRANTY; without even the implied warranty of
  6124      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  6125      GNU Lesser General Public License for more details.
  6126  
  6127      You should have received a copy of the GNU Lesser General Public License
  6128      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  6129  */
  6130  /**
  6131   * @file namereg.js
  6132   * @author Marek Kotewicz <marek@ethdev.com>
  6133   * @date 2015
  6134   */
  6135  
  6136  var globalRegistrarAbi = require('../contracts/GlobalRegistrar.json');
  6137  var icapRegistrarAbi= require('../contracts/ICAPRegistrar.json');
  6138  
  6139  var globalNameregAddress = '0xc6d9d2cd449a754c494264e1809c50e34d64562b';
  6140  var icapNameregAddress = '0xa1a111bc074c9cfa781f0c38e63bd51c91b8af00';
  6141  
  6142  module.exports = {
  6143      global: {
  6144          abi: globalRegistrarAbi,
  6145          address: globalNameregAddress
  6146      },
  6147      icap: {
  6148          abi: icapRegistrarAbi,
  6149          address: icapNameregAddress
  6150      }
  6151  };
  6152  
  6153  
  6154  },{"../contracts/GlobalRegistrar.json":1,"../contracts/ICAPRegistrar.json":2}],45:[function(require,module,exports){
  6155  /*
  6156      This file is part of web3.js.
  6157  
  6158      web3.js is free software: you can redistribute it and/or modify
  6159      it under the terms of the GNU Lesser General Public License as published by
  6160      the Free Software Foundation, either version 3 of the License, or
  6161      (at your option) any later version.
  6162  
  6163      web3.js is distributed in the hope that it will be useful,
  6164      but WITHOUT ANY WARRANTY; without even the implied warranty of
  6165      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  6166      GNU Lesser General Public License for more details.
  6167  
  6168      You should have received a copy of the GNU Lesser General Public License
  6169      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  6170  */
  6171  /**
  6172   * @file property.js
  6173   * @author Fabian Vogelsteller <fabian@frozeman.de>
  6174   * @author Marek Kotewicz <marek@ethdev.com>
  6175   * @date 2015
  6176   */
  6177  
  6178  var utils = require('../utils/utils');
  6179  
  6180  var Property = function (options) {
  6181      this.name = options.name;
  6182      this.getter = options.getter;
  6183      this.setter = options.setter;
  6184      this.outputFormatter = options.outputFormatter;
  6185      this.inputFormatter = options.inputFormatter;
  6186      this.requestManager = null;
  6187  };
  6188  
  6189  Property.prototype.setRequestManager = function (rm) {
  6190      this.requestManager = rm;
  6191  };
  6192  
  6193  /**
  6194   * Should be called to format input args of method
  6195   *
  6196   * @method formatInput
  6197   * @param {Array}
  6198   * @return {Array}
  6199   */
  6200  Property.prototype.formatInput = function (arg) {
  6201      return this.inputFormatter ? this.inputFormatter(arg) : arg;
  6202  };
  6203  
  6204  /**
  6205   * Should be called to format output(result) of method
  6206   *
  6207   * @method formatOutput
  6208   * @param {Object}
  6209   * @return {Object}
  6210   */
  6211  Property.prototype.formatOutput = function (result) {
  6212      return this.outputFormatter && result !== null && result !== undefined ? this.outputFormatter(result) : result;
  6213  };
  6214  
  6215  /**
  6216   * Should be used to extract callback from array of arguments. Modifies input param
  6217   *
  6218   * @method extractCallback
  6219   * @param {Array} arguments
  6220   * @return {Function|Null} callback, if exists
  6221   */
  6222  Property.prototype.extractCallback = function (args) {
  6223      if (utils.isFunction(args[args.length - 1])) {
  6224          return args.pop(); // modify the args array!
  6225      }
  6226  };
  6227  
  6228  
  6229  /**
  6230   * Should attach function to method
  6231   *
  6232   * @method attachToObject
  6233   * @param {Object}
  6234   * @param {Function}
  6235   */
  6236  Property.prototype.attachToObject = function (obj) {
  6237      var proto = {
  6238          get: this.buildGet(),
  6239          enumerable: true
  6240      };
  6241  
  6242      var names = this.name.split('.');
  6243      var name = names[0];
  6244      if (names.length > 1) {
  6245          obj[names[0]] = obj[names[0]] || {};
  6246          obj = obj[names[0]];
  6247          name = names[1];
  6248      }
  6249  
  6250      Object.defineProperty(obj, name, proto);
  6251      obj[asyncGetterName(name)] = this.buildAsyncGet();
  6252  };
  6253  
  6254  var asyncGetterName = function (name) {
  6255      return 'get' + name.charAt(0).toUpperCase() + name.slice(1);
  6256  };
  6257  
  6258  Property.prototype.buildGet = function () {
  6259      var property = this;
  6260      return function get() {
  6261          return property.formatOutput(property.requestManager.send({
  6262              method: property.getter
  6263          }));
  6264      };
  6265  };
  6266  
  6267  Property.prototype.buildAsyncGet = function () {
  6268      var property = this;
  6269      var get = function (callback) {
  6270          property.requestManager.sendAsync({
  6271              method: property.getter
  6272          }, function (err, result) {
  6273              callback(err, property.formatOutput(result));
  6274          });
  6275      };
  6276      get.request = this.request.bind(this);
  6277      return get;
  6278  };
  6279  
  6280  /**
  6281   * Should be called to create pure JSONRPC request which can be used in batch request
  6282   *
  6283   * @method request
  6284   * @param {...} params
  6285   * @return {Object} jsonrpc request
  6286   */
  6287  Property.prototype.request = function () {
  6288      var payload = {
  6289          method: this.getter,
  6290          params: [],
  6291          callback: this.extractCallback(Array.prototype.slice.call(arguments))
  6292      };
  6293      payload.format = this.formatOutput.bind(this);
  6294      return payload;
  6295  };
  6296  
  6297  module.exports = Property;
  6298  
  6299  
  6300  },{"../utils/utils":20}],46:[function(require,module,exports){
  6301  /*
  6302      This file is part of web3.js.
  6303  
  6304      web3.js is free software: you can redistribute it and/or modify
  6305      it under the terms of the GNU Lesser General Public License as published by
  6306      the Free Software Foundation, either version 3 of the License, or
  6307      (at your option) any later version.
  6308  
  6309      web3.js is distributed in the hope that it will be useful,
  6310      but WITHOUT ANY WARRANTY; without even the implied warranty of
  6311      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  6312      GNU Lesser General Public License for more details.
  6313  
  6314      You should have received a copy of the GNU Lesser General Public License
  6315      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  6316  */
  6317  /**
  6318   * @file requestmanager.js
  6319   * @author Jeffrey Wilcke <jeff@ethdev.com>
  6320   * @author Marek Kotewicz <marek@ethdev.com>
  6321   * @author Marian Oancea <marian@ethdev.com>
  6322   * @author Fabian Vogelsteller <fabian@ethdev.com>
  6323   * @author Gav Wood <g@ethdev.com>
  6324   * @date 2014
  6325   */
  6326  
  6327  var Jsonrpc = require('./jsonrpc');
  6328  var utils = require('../utils/utils');
  6329  var c = require('../utils/config');
  6330  var errors = require('./errors');
  6331  
  6332  /**
  6333   * It's responsible for passing messages to providers
  6334   * It's also responsible for polling the ebakus node for incoming messages
  6335   * Default poll timeout is 1 second
  6336   * Singleton
  6337   */
  6338  var RequestManager = function (provider) {
  6339      this.provider = provider;
  6340      this.polls = {};
  6341      this.timeout = null;
  6342  };
  6343  
  6344  /**
  6345   * Should be used to synchronously send request
  6346   *
  6347   * @method send
  6348   * @param {Object} data
  6349   * @return {Object}
  6350   */
  6351  RequestManager.prototype.send = function (data) {
  6352      if (!this.provider) {
  6353          console.error(errors.InvalidProvider());
  6354          return null;
  6355      }
  6356  
  6357      var payload = Jsonrpc.toPayload(data.method, data.params);
  6358      var result = this.provider.send(payload);
  6359  
  6360      if (!Jsonrpc.isValidResponse(result)) {
  6361          throw errors.InvalidResponse(result);
  6362      }
  6363  
  6364      return result.result;
  6365  };
  6366  
  6367  /**
  6368   * Should be used to asynchronously send request
  6369   *
  6370   * @method sendAsync
  6371   * @param {Object} data
  6372   * @param {Function} callback
  6373   */
  6374  RequestManager.prototype.sendAsync = function (data, callback) {
  6375      if (!this.provider) {
  6376          return callback(errors.InvalidProvider());
  6377      }
  6378  
  6379      var payload = Jsonrpc.toPayload(data.method, data.params);
  6380      this.provider.sendAsync(payload, function (err, result) {
  6381          if (err) {
  6382              return callback(err);
  6383          }
  6384  
  6385          if (!Jsonrpc.isValidResponse(result)) {
  6386              return callback(errors.InvalidResponse(result));
  6387          }
  6388  
  6389          callback(null, result.result);
  6390      });
  6391  };
  6392  
  6393  /**
  6394   * Should be called to asynchronously send batch request
  6395   *
  6396   * @method sendBatch
  6397   * @param {Array} batch data
  6398   * @param {Function} callback
  6399   */
  6400  RequestManager.prototype.sendBatch = function (data, callback) {
  6401      if (!this.provider) {
  6402          return callback(errors.InvalidProvider());
  6403      }
  6404  
  6405      var payload = Jsonrpc.toBatchPayload(data);
  6406  
  6407      this.provider.sendAsync(payload, function (err, results) {
  6408          if (err) {
  6409              return callback(err);
  6410          }
  6411  
  6412          if (!utils.isArray(results)) {
  6413              return callback(errors.InvalidResponse(results));
  6414          }
  6415  
  6416          callback(err, results);
  6417      });
  6418  };
  6419  
  6420  /**
  6421   * Should be used to set provider of request manager
  6422   *
  6423   * @method setProvider
  6424   * @param {Object}
  6425   */
  6426  RequestManager.prototype.setProvider = function (p) {
  6427      this.provider = p;
  6428  };
  6429  
  6430  /**
  6431   * Should be used to start polling
  6432   *
  6433   * @method startPolling
  6434   * @param {Object} data
  6435   * @param {Number} pollId
  6436   * @param {Function} callback
  6437   * @param {Function} uninstall
  6438   *
  6439   * @todo cleanup number of params
  6440   */
  6441  RequestManager.prototype.startPolling = function (data, pollId, callback, uninstall) {
  6442      this.polls[pollId] = {data: data, id: pollId, callback: callback, uninstall: uninstall};
  6443  
  6444  
  6445      // start polling
  6446      if (!this.timeout) {
  6447          this.poll();
  6448      }
  6449  };
  6450  
  6451  /**
  6452   * Should be used to stop polling for filter with given id
  6453   *
  6454   * @method stopPolling
  6455   * @param {Number} pollId
  6456   */
  6457  RequestManager.prototype.stopPolling = function (pollId) {
  6458      delete this.polls[pollId];
  6459  
  6460      // stop polling
  6461      if(Object.keys(this.polls).length === 0 && this.timeout) {
  6462          clearTimeout(this.timeout);
  6463          this.timeout = null;
  6464      }
  6465  };
  6466  
  6467  /**
  6468   * Should be called to reset the polling mechanism of the request manager
  6469   *
  6470   * @method reset
  6471   */
  6472  RequestManager.prototype.reset = function (keepIsSyncing) {
  6473      /*jshint maxcomplexity:5 */
  6474  
  6475      for (var key in this.polls) {
  6476          // remove all polls, except sync polls,
  6477          // they need to be removed manually by calling syncing.stopWatching()
  6478          if(!keepIsSyncing || key.indexOf('syncPoll_') === -1) {
  6479              this.polls[key].uninstall();
  6480              delete this.polls[key];
  6481          }
  6482      }
  6483  
  6484      // stop polling
  6485      if(Object.keys(this.polls).length === 0 && this.timeout) {
  6486          clearTimeout(this.timeout);
  6487          this.timeout = null;
  6488      }
  6489  };
  6490  
  6491  /**
  6492   * Should be called to poll for changes on filter with given id
  6493   *
  6494   * @method poll
  6495   */
  6496  RequestManager.prototype.poll = function () {
  6497      /*jshint maxcomplexity: 6 */
  6498      this.timeout = setTimeout(this.poll.bind(this), c.ETH_POLLING_TIMEOUT);
  6499  
  6500      if (Object.keys(this.polls).length === 0) {
  6501          return;
  6502      }
  6503  
  6504      if (!this.provider) {
  6505          console.error(errors.InvalidProvider());
  6506          return;
  6507      }
  6508  
  6509      var pollsData = [];
  6510      var pollsIds = [];
  6511      for (var key in this.polls) {
  6512          pollsData.push(this.polls[key].data);
  6513          pollsIds.push(key);
  6514      }
  6515  
  6516      if (pollsData.length === 0) {
  6517          return;
  6518      }
  6519  
  6520      var payload = Jsonrpc.toBatchPayload(pollsData);
  6521  
  6522      // map the request id to they poll id
  6523      var pollsIdMap = {};
  6524      payload.forEach(function(load, index){
  6525          pollsIdMap[load.id] = pollsIds[index];
  6526      });
  6527  
  6528  
  6529      var self = this;
  6530      this.provider.sendAsync(payload, function (error, results) {
  6531  
  6532  
  6533          // TODO: console log?
  6534          if (error) {
  6535              return;
  6536          }
  6537  
  6538          if (!utils.isArray(results)) {
  6539              throw errors.InvalidResponse(results);
  6540          }
  6541          results.map(function (result) {
  6542              var id = pollsIdMap[result.id];
  6543  
  6544              // make sure the filter is still installed after arrival of the request
  6545              if (self.polls[id]) {
  6546                  result.callback = self.polls[id].callback;
  6547                  return result;
  6548              } else
  6549                  return false;
  6550          }).filter(function (result) {
  6551              return !!result;
  6552          }).filter(function (result) {
  6553              var valid = Jsonrpc.isValidResponse(result);
  6554              if (!valid) {
  6555                  result.callback(errors.InvalidResponse(result));
  6556              }
  6557              return valid;
  6558          }).forEach(function (result) {
  6559              result.callback(null, result.result);
  6560          });
  6561      });
  6562  };
  6563  
  6564  module.exports = RequestManager;
  6565  
  6566  
  6567  },{"../utils/config":18,"../utils/utils":20,"./errors":26,"./jsonrpc":35}],47:[function(require,module,exports){
  6568  
  6569  
  6570  var Settings = function () {
  6571      this.defaultBlock = 'latest';
  6572      this.defaultAccount = undefined;
  6573  };
  6574  
  6575  module.exports = Settings;
  6576  
  6577  
  6578  },{}],48:[function(require,module,exports){
  6579  /*
  6580      This file is part of web3.js.
  6581  
  6582      web3.js is free software: you can redistribute it and/or modify
  6583      it under the terms of the GNU Lesser General Public License as published by
  6584      the Free Software Foundation, either version 3 of the License, or
  6585      (at your option) any later version.
  6586  
  6587      web3.js is distributed in the hope that it will be useful,
  6588      but WITHOUT ANY WARRANTY; without even the implied warranty of
  6589      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  6590      GNU Lesser General Public License for more details.
  6591  
  6592      You should have received a copy of the GNU Lesser General Public License
  6593      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  6594  */
  6595  /** @file syncing.js
  6596   * @authors:
  6597   *   Fabian Vogelsteller <fabian@ethdev.com>
  6598   * @date 2015
  6599   */
  6600  
  6601  var formatters = require('./formatters');
  6602  var utils = require('../utils/utils');
  6603  
  6604  var count = 1;
  6605  
  6606  /**
  6607  Adds the callback and sets up the methods, to iterate over the results.
  6608  
  6609  @method pollSyncing
  6610  @param {Object} self
  6611  */
  6612  var pollSyncing = function(self) {
  6613  
  6614      var onMessage = function (error, sync) {
  6615          if (error) {
  6616              return self.callbacks.forEach(function (callback) {
  6617                  callback(error);
  6618              });
  6619          }
  6620  
  6621          if(utils.isObject(sync) && sync.startingBlock)
  6622              sync = formatters.outputSyncingFormatter(sync);
  6623  
  6624          self.callbacks.forEach(function (callback) {
  6625              if (self.lastSyncState !== sync) {
  6626  
  6627                  // call the callback with true first so the app can stop anything, before receiving the sync data
  6628                  if(!self.lastSyncState && utils.isObject(sync))
  6629                      callback(null, true);
  6630  
  6631                  // call on the next CPU cycle, so the actions of the sync stop can be processes first
  6632                  setTimeout(function() {
  6633                      callback(null, sync);
  6634                  }, 0);
  6635  
  6636                  self.lastSyncState = sync;
  6637              }
  6638          });
  6639      };
  6640  
  6641      self.requestManager.startPolling({
  6642          method: 'eth_syncing',
  6643          params: [],
  6644      }, self.pollId, onMessage, self.stopWatching.bind(self));
  6645  
  6646  };
  6647  
  6648  var IsSyncing = function (requestManager, callback) {
  6649      this.requestManager = requestManager;
  6650      this.pollId = 'syncPoll_'+ count++;
  6651      this.callbacks = [];
  6652      this.addCallback(callback);
  6653      this.lastSyncState = false;
  6654      pollSyncing(this);
  6655  
  6656      return this;
  6657  };
  6658  
  6659  IsSyncing.prototype.addCallback = function (callback) {
  6660      if(callback)
  6661          this.callbacks.push(callback);
  6662      return this;
  6663  };
  6664  
  6665  IsSyncing.prototype.stopWatching = function () {
  6666      this.requestManager.stopPolling(this.pollId);
  6667      this.callbacks = [];
  6668  };
  6669  
  6670  module.exports = IsSyncing;
  6671  
  6672  
  6673  },{"../utils/utils":20,"./formatters":30}],49:[function(require,module,exports){
  6674  /*
  6675      This file is part of web3.js.
  6676  
  6677      web3.js is free software: you can redistribute it and/or modify
  6678      it under the terms of the GNU Lesser General Public License as published by
  6679      the Free Software Foundation, either version 3 of the License, or
  6680      (at your option) any later version.
  6681  
  6682      web3.js is distributed in the hope that it will be useful,
  6683      but WITHOUT ANY WARRANTY; without even the implied warranty of
  6684      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  6685      GNU Lesser General Public License for more details.
  6686  
  6687      You should have received a copy of the GNU Lesser General Public License
  6688      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  6689  */
  6690  /**
  6691   * @file transfer.js
  6692   * @author Marek Kotewicz <marek@ethdev.com>
  6693   * @date 2015
  6694   */
  6695  
  6696  var Iban = require('./iban');
  6697  var exchangeAbi = require('../contracts/SmartExchange.json');
  6698  
  6699  /**
  6700   * Should be used to make Iban transfer
  6701   *
  6702   * @method transfer
  6703   * @param {String} from
  6704   * @param {String} to iban
  6705   * @param {Value} value to be tranfered
  6706   * @param {Function} callback, callback
  6707   */
  6708  var transfer = function (eth, from, to, value, callback) {
  6709      var iban = new Iban(to);
  6710      if (!iban.isValid()) {
  6711          throw new Error('invalid iban address');
  6712      }
  6713  
  6714      if (iban.isDirect()) {
  6715          return transferToAddress(eth, from, iban.address(), value, callback);
  6716      }
  6717  
  6718      if (!callback) {
  6719          var address = eth.icapNamereg().addr(iban.institution());
  6720          return deposit(eth, from, address, value, iban.client());
  6721      }
  6722  
  6723      eth.icapNamereg().addr(iban.institution(), function (err, address) {
  6724          return deposit(eth, from, address, value, iban.client(), callback);
  6725      });
  6726  
  6727  };
  6728  
  6729  /**
  6730   * Should be used to transfer funds to certain address
  6731   *
  6732   * @method transferToAddress
  6733   * @param {String} from
  6734   * @param {String} to
  6735   * @param {Value} value to be tranfered
  6736   * @param {Function} callback, callback
  6737   */
  6738  var transferToAddress = function (eth, from, to, value, callback) {
  6739      return eth.sendTransaction({
  6740          address: to,
  6741          from: from,
  6742          value: value
  6743      }, callback);
  6744  };
  6745  
  6746  /**
  6747   * Should be used to deposit funds to generic Exchange contract (must implement deposit(bytes32) method!)
  6748   *
  6749   * @method deposit
  6750   * @param {String} from
  6751   * @param {String} to
  6752   * @param {Value} value to be transferred
  6753   * @param {String} client unique identifier
  6754   * @param {Function} callback, callback
  6755   */
  6756  var deposit = function (eth, from, to, value, client, callback) {
  6757      var abi = exchangeAbi;
  6758      return eth.contract(abi).at(to).deposit(client, {
  6759          from: from,
  6760          value: value
  6761      }, callback);
  6762  };
  6763  
  6764  module.exports = transfer;
  6765  
  6766  
  6767  },{"../contracts/SmartExchange.json":3,"./iban":33}],50:[function(require,module,exports){
  6768  
  6769  },{}],51:[function(require,module,exports){
  6770  ;(function (root, factory, undef) {
  6771  	if (typeof exports === "object") {
  6772  		// CommonJS
  6773  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
  6774  	}
  6775  	else if (typeof define === "function" && define.amd) {
  6776  		// AMD
  6777  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
  6778  	}
  6779  	else {
  6780  		// Global (browser)
  6781  		factory(root.CryptoJS);
  6782  	}
  6783  }(this, function (CryptoJS) {
  6784  
  6785  	(function () {
  6786  	    // Shortcuts
  6787  	    var C = CryptoJS;
  6788  	    var C_lib = C.lib;
  6789  	    var BlockCipher = C_lib.BlockCipher;
  6790  	    var C_algo = C.algo;
  6791  
  6792  	    // Lookup tables
  6793  	    var SBOX = [];
  6794  	    var INV_SBOX = [];
  6795  	    var SUB_MIX_0 = [];
  6796  	    var SUB_MIX_1 = [];
  6797  	    var SUB_MIX_2 = [];
  6798  	    var SUB_MIX_3 = [];
  6799  	    var INV_SUB_MIX_0 = [];
  6800  	    var INV_SUB_MIX_1 = [];
  6801  	    var INV_SUB_MIX_2 = [];
  6802  	    var INV_SUB_MIX_3 = [];
  6803  
  6804  	    // Compute lookup tables
  6805  	    (function () {
  6806  	        // Compute double table
  6807  	        var d = [];
  6808  	        for (var i = 0; i < 256; i++) {
  6809  	            if (i < 128) {
  6810  	                d[i] = i << 1;
  6811  	            } else {
  6812  	                d[i] = (i << 1) ^ 0x11b;
  6813  	            }
  6814  	        }
  6815  
  6816  	        // Walk GF(2^8)
  6817  	        var x = 0;
  6818  	        var xi = 0;
  6819  	        for (var i = 0; i < 256; i++) {
  6820  	            // Compute sbox
  6821  	            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
  6822  	            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
  6823  	            SBOX[x] = sx;
  6824  	            INV_SBOX[sx] = x;
  6825  
  6826  	            // Compute multiplication
  6827  	            var x2 = d[x];
  6828  	            var x4 = d[x2];
  6829  	            var x8 = d[x4];
  6830  
  6831  	            // Compute sub bytes, mix columns tables
  6832  	            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
  6833  	            SUB_MIX_0[x] = (t << 24) | (t >>> 8);
  6834  	            SUB_MIX_1[x] = (t << 16) | (t >>> 16);
  6835  	            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
  6836  	            SUB_MIX_3[x] = t;
  6837  
  6838  	            // Compute inv sub bytes, inv mix columns tables
  6839  	            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
  6840  	            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
  6841  	            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
  6842  	            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
  6843  	            INV_SUB_MIX_3[sx] = t;
  6844  
  6845  	            // Compute next counter
  6846  	            if (!x) {
  6847  	                x = xi = 1;
  6848  	            } else {
  6849  	                x = x2 ^ d[d[d[x8 ^ x2]]];
  6850  	                xi ^= d[d[xi]];
  6851  	            }
  6852  	        }
  6853  	    }());
  6854  
  6855  	    // Precomputed Rcon lookup
  6856  	    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
  6857  
  6858  	    /**
  6859  	     * AES block cipher algorithm.
  6860  	     */
  6861  	    var AES = C_algo.AES = BlockCipher.extend({
  6862  	        _doReset: function () {
  6863  	            // Skip reset of nRounds has been set before and key did not change
  6864  	            if (this._nRounds && this._keyPriorReset === this._key) {
  6865  	                return;
  6866  	            }
  6867  
  6868  	            // Shortcuts
  6869  	            var key = this._keyPriorReset = this._key;
  6870  	            var keyWords = key.words;
  6871  	            var keySize = key.sigBytes / 4;
  6872  
  6873  	            // Compute number of rounds
  6874  	            var nRounds = this._nRounds = keySize + 6;
  6875  
  6876  	            // Compute number of key schedule rows
  6877  	            var ksRows = (nRounds + 1) * 4;
  6878  
  6879  	            // Compute key schedule
  6880  	            var keySchedule = this._keySchedule = [];
  6881  	            for (var ksRow = 0; ksRow < ksRows; ksRow++) {
  6882  	                if (ksRow < keySize) {
  6883  	                    keySchedule[ksRow] = keyWords[ksRow];
  6884  	                } else {
  6885  	                    var t = keySchedule[ksRow - 1];
  6886  
  6887  	                    if (!(ksRow % keySize)) {
  6888  	                        // Rot word
  6889  	                        t = (t << 8) | (t >>> 24);
  6890  
  6891  	                        // Sub word
  6892  	                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
  6893  
  6894  	                        // Mix Rcon
  6895  	                        t ^= RCON[(ksRow / keySize) | 0] << 24;
  6896  	                    } else if (keySize > 6 && ksRow % keySize == 4) {
  6897  	                        // Sub word
  6898  	                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
  6899  	                    }
  6900  
  6901  	                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
  6902  	                }
  6903  	            }
  6904  
  6905  	            // Compute inv key schedule
  6906  	            var invKeySchedule = this._invKeySchedule = [];
  6907  	            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
  6908  	                var ksRow = ksRows - invKsRow;
  6909  
  6910  	                if (invKsRow % 4) {
  6911  	                    var t = keySchedule[ksRow];
  6912  	                } else {
  6913  	                    var t = keySchedule[ksRow - 4];
  6914  	                }
  6915  
  6916  	                if (invKsRow < 4 || ksRow <= 4) {
  6917  	                    invKeySchedule[invKsRow] = t;
  6918  	                } else {
  6919  	                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
  6920  	                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
  6921  	                }
  6922  	            }
  6923  	        },
  6924  
  6925  	        encryptBlock: function (M, offset) {
  6926  	            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
  6927  	        },
  6928  
  6929  	        decryptBlock: function (M, offset) {
  6930  	            // Swap 2nd and 4th rows
  6931  	            var t = M[offset + 1];
  6932  	            M[offset + 1] = M[offset + 3];
  6933  	            M[offset + 3] = t;
  6934  
  6935  	            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
  6936  
  6937  	            // Inv swap 2nd and 4th rows
  6938  	            var t = M[offset + 1];
  6939  	            M[offset + 1] = M[offset + 3];
  6940  	            M[offset + 3] = t;
  6941  	        },
  6942  
  6943  	        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
  6944  	            // Shortcut
  6945  	            var nRounds = this._nRounds;
  6946  
  6947  	            // Get input, add round key
  6948  	            var s0 = M[offset]     ^ keySchedule[0];
  6949  	            var s1 = M[offset + 1] ^ keySchedule[1];
  6950  	            var s2 = M[offset + 2] ^ keySchedule[2];
  6951  	            var s3 = M[offset + 3] ^ keySchedule[3];
  6952  
  6953  	            // Key schedule row counter
  6954  	            var ksRow = 4;
  6955  
  6956  	            // Rounds
  6957  	            for (var round = 1; round < nRounds; round++) {
  6958  	                // Shift rows, sub bytes, mix columns, add round key
  6959  	                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++];
  6960  	                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++];
  6961  	                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++];
  6962  	                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++];
  6963  
  6964  	                // Update state
  6965  	                s0 = t0;
  6966  	                s1 = t1;
  6967  	                s2 = t2;
  6968  	                s3 = t3;
  6969  	            }
  6970  
  6971  	            // Shift rows, sub bytes, add round key
  6972  	            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
  6973  	            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
  6974  	            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
  6975  	            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
  6976  
  6977  	            // Set output
  6978  	            M[offset]     = t0;
  6979  	            M[offset + 1] = t1;
  6980  	            M[offset + 2] = t2;
  6981  	            M[offset + 3] = t3;
  6982  	        },
  6983  
  6984  	        keySize: 256/32
  6985  	    });
  6986  
  6987  	    /**
  6988  	     * Shortcut functions to the cipher's object interface.
  6989  	     *
  6990  	     * @example
  6991  	     *
  6992  	     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
  6993  	     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
  6994  	     */
  6995  	    C.AES = BlockCipher._createHelper(AES);
  6996  	}());
  6997  
  6998  
  6999  	return CryptoJS.AES;
  7000  
  7001  }));
  7002  },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],52:[function(require,module,exports){
  7003  ;(function (root, factory) {
  7004  	if (typeof exports === "object") {
  7005  		// CommonJS
  7006  		module.exports = exports = factory(require("./core"));
  7007  	}
  7008  	else if (typeof define === "function" && define.amd) {
  7009  		// AMD
  7010  		define(["./core"], factory);
  7011  	}
  7012  	else {
  7013  		// Global (browser)
  7014  		factory(root.CryptoJS);
  7015  	}
  7016  }(this, function (CryptoJS) {
  7017  
  7018  	/**
  7019  	 * Cipher core components.
  7020  	 */
  7021  	CryptoJS.lib.Cipher || (function (undefined) {
  7022  	    // Shortcuts
  7023  	    var C = CryptoJS;
  7024  	    var C_lib = C.lib;
  7025  	    var Base = C_lib.Base;
  7026  	    var WordArray = C_lib.WordArray;
  7027  	    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
  7028  	    var C_enc = C.enc;
  7029  	    var Utf8 = C_enc.Utf8;
  7030  	    var Base64 = C_enc.Base64;
  7031  	    var C_algo = C.algo;
  7032  	    var EvpKDF = C_algo.EvpKDF;
  7033  
  7034  	    /**
  7035  	     * Abstract base cipher template.
  7036  	     *
  7037  	     * @property {number} keySize This cipher's key size. Default: 4 (128 bits)
  7038  	     * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
  7039  	     * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
  7040  	     * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
  7041  	     */
  7042  	    var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
  7043  	        /**
  7044  	         * Configuration options.
  7045  	         *
  7046  	         * @property {WordArray} iv The IV to use for this operation.
  7047  	         */
  7048  	        cfg: Base.extend(),
  7049  
  7050  	        /**
  7051  	         * Creates this cipher in encryption mode.
  7052  	         *
  7053  	         * @param {WordArray} key The key.
  7054  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7055  	         *
  7056  	         * @return {Cipher} A cipher instance.
  7057  	         *
  7058  	         * @static
  7059  	         *
  7060  	         * @example
  7061  	         *
  7062  	         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
  7063  	         */
  7064  	        createEncryptor: function (key, cfg) {
  7065  	            return this.create(this._ENC_XFORM_MODE, key, cfg);
  7066  	        },
  7067  
  7068  	        /**
  7069  	         * Creates this cipher in decryption mode.
  7070  	         *
  7071  	         * @param {WordArray} key The key.
  7072  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7073  	         *
  7074  	         * @return {Cipher} A cipher instance.
  7075  	         *
  7076  	         * @static
  7077  	         *
  7078  	         * @example
  7079  	         *
  7080  	         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
  7081  	         */
  7082  	        createDecryptor: function (key, cfg) {
  7083  	            return this.create(this._DEC_XFORM_MODE, key, cfg);
  7084  	        },
  7085  
  7086  	        /**
  7087  	         * Initializes a newly created cipher.
  7088  	         *
  7089  	         * @param {number} xformMode Either the encryption or decryption transormation mode constant.
  7090  	         * @param {WordArray} key The key.
  7091  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7092  	         *
  7093  	         * @example
  7094  	         *
  7095  	         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
  7096  	         */
  7097  	        init: function (xformMode, key, cfg) {
  7098  	            // Apply config defaults
  7099  	            this.cfg = this.cfg.extend(cfg);
  7100  
  7101  	            // Store transform mode and key
  7102  	            this._xformMode = xformMode;
  7103  	            this._key = key;
  7104  
  7105  	            // Set initial values
  7106  	            this.reset();
  7107  	        },
  7108  
  7109  	        /**
  7110  	         * Resets this cipher to its initial state.
  7111  	         *
  7112  	         * @example
  7113  	         *
  7114  	         *     cipher.reset();
  7115  	         */
  7116  	        reset: function () {
  7117  	            // Reset data buffer
  7118  	            BufferedBlockAlgorithm.reset.call(this);
  7119  
  7120  	            // Perform concrete-cipher logic
  7121  	            this._doReset();
  7122  	        },
  7123  
  7124  	        /**
  7125  	         * Adds data to be encrypted or decrypted.
  7126  	         *
  7127  	         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
  7128  	         *
  7129  	         * @return {WordArray} The data after processing.
  7130  	         *
  7131  	         * @example
  7132  	         *
  7133  	         *     var encrypted = cipher.process('data');
  7134  	         *     var encrypted = cipher.process(wordArray);
  7135  	         */
  7136  	        process: function (dataUpdate) {
  7137  	            // Append
  7138  	            this._append(dataUpdate);
  7139  
  7140  	            // Process available blocks
  7141  	            return this._process();
  7142  	        },
  7143  
  7144  	        /**
  7145  	         * Finalizes the encryption or decryption process.
  7146  	         * Note that the finalize operation is effectively a destructive, read-once operation.
  7147  	         *
  7148  	         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
  7149  	         *
  7150  	         * @return {WordArray} The data after final processing.
  7151  	         *
  7152  	         * @example
  7153  	         *
  7154  	         *     var encrypted = cipher.finalize();
  7155  	         *     var encrypted = cipher.finalize('data');
  7156  	         *     var encrypted = cipher.finalize(wordArray);
  7157  	         */
  7158  	        finalize: function (dataUpdate) {
  7159  	            // Final data update
  7160  	            if (dataUpdate) {
  7161  	                this._append(dataUpdate);
  7162  	            }
  7163  
  7164  	            // Perform concrete-cipher logic
  7165  	            var finalProcessedData = this._doFinalize();
  7166  
  7167  	            return finalProcessedData;
  7168  	        },
  7169  
  7170  	        keySize: 128/32,
  7171  
  7172  	        ivSize: 128/32,
  7173  
  7174  	        _ENC_XFORM_MODE: 1,
  7175  
  7176  	        _DEC_XFORM_MODE: 2,
  7177  
  7178  	        /**
  7179  	         * Creates shortcut functions to a cipher's object interface.
  7180  	         *
  7181  	         * @param {Cipher} cipher The cipher to create a helper for.
  7182  	         *
  7183  	         * @return {Object} An object with encrypt and decrypt shortcut functions.
  7184  	         *
  7185  	         * @static
  7186  	         *
  7187  	         * @example
  7188  	         *
  7189  	         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
  7190  	         */
  7191  	        _createHelper: (function () {
  7192  	            function selectCipherStrategy(key) {
  7193  	                if (typeof key == 'string') {
  7194  	                    return PasswordBasedCipher;
  7195  	                } else {
  7196  	                    return SerializableCipher;
  7197  	                }
  7198  	            }
  7199  
  7200  	            return function (cipher) {
  7201  	                return {
  7202  	                    encrypt: function (message, key, cfg) {
  7203  	                        return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
  7204  	                    },
  7205  
  7206  	                    decrypt: function (ciphertext, key, cfg) {
  7207  	                        return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
  7208  	                    }
  7209  	                };
  7210  	            };
  7211  	        }())
  7212  	    });
  7213  
  7214  	    /**
  7215  	     * Abstract base stream cipher template.
  7216  	     *
  7217  	     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
  7218  	     */
  7219  	    var StreamCipher = C_lib.StreamCipher = Cipher.extend({
  7220  	        _doFinalize: function () {
  7221  	            // Process partial blocks
  7222  	            var finalProcessedBlocks = this._process(!!'flush');
  7223  
  7224  	            return finalProcessedBlocks;
  7225  	        },
  7226  
  7227  	        blockSize: 1
  7228  	    });
  7229  
  7230  	    /**
  7231  	     * Mode namespace.
  7232  	     */
  7233  	    var C_mode = C.mode = {};
  7234  
  7235  	    /**
  7236  	     * Abstract base block cipher mode template.
  7237  	     */
  7238  	    var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
  7239  	        /**
  7240  	         * Creates this mode for encryption.
  7241  	         *
  7242  	         * @param {Cipher} cipher A block cipher instance.
  7243  	         * @param {Array} iv The IV words.
  7244  	         *
  7245  	         * @static
  7246  	         *
  7247  	         * @example
  7248  	         *
  7249  	         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
  7250  	         */
  7251  	        createEncryptor: function (cipher, iv) {
  7252  	            return this.Encryptor.create(cipher, iv);
  7253  	        },
  7254  
  7255  	        /**
  7256  	         * Creates this mode for decryption.
  7257  	         *
  7258  	         * @param {Cipher} cipher A block cipher instance.
  7259  	         * @param {Array} iv The IV words.
  7260  	         *
  7261  	         * @static
  7262  	         *
  7263  	         * @example
  7264  	         *
  7265  	         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
  7266  	         */
  7267  	        createDecryptor: function (cipher, iv) {
  7268  	            return this.Decryptor.create(cipher, iv);
  7269  	        },
  7270  
  7271  	        /**
  7272  	         * Initializes a newly created mode.
  7273  	         *
  7274  	         * @param {Cipher} cipher A block cipher instance.
  7275  	         * @param {Array} iv The IV words.
  7276  	         *
  7277  	         * @example
  7278  	         *
  7279  	         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
  7280  	         */
  7281  	        init: function (cipher, iv) {
  7282  	            this._cipher = cipher;
  7283  	            this._iv = iv;
  7284  	        }
  7285  	    });
  7286  
  7287  	    /**
  7288  	     * Cipher Block Chaining mode.
  7289  	     */
  7290  	    var CBC = C_mode.CBC = (function () {
  7291  	        /**
  7292  	         * Abstract base CBC mode.
  7293  	         */
  7294  	        var CBC = BlockCipherMode.extend();
  7295  
  7296  	        /**
  7297  	         * CBC encryptor.
  7298  	         */
  7299  	        CBC.Encryptor = CBC.extend({
  7300  	            /**
  7301  	             * Processes the data block at offset.
  7302  	             *
  7303  	             * @param {Array} words The data words to operate on.
  7304  	             * @param {number} offset The offset where the block starts.
  7305  	             *
  7306  	             * @example
  7307  	             *
  7308  	             *     mode.processBlock(data.words, offset);
  7309  	             */
  7310  	            processBlock: function (words, offset) {
  7311  	                // Shortcuts
  7312  	                var cipher = this._cipher;
  7313  	                var blockSize = cipher.blockSize;
  7314  
  7315  	                // XOR and encrypt
  7316  	                xorBlock.call(this, words, offset, blockSize);
  7317  	                cipher.encryptBlock(words, offset);
  7318  
  7319  	                // Remember this block to use with next block
  7320  	                this._prevBlock = words.slice(offset, offset + blockSize);
  7321  	            }
  7322  	        });
  7323  
  7324  	        /**
  7325  	         * CBC decryptor.
  7326  	         */
  7327  	        CBC.Decryptor = CBC.extend({
  7328  	            /**
  7329  	             * Processes the data block at offset.
  7330  	             *
  7331  	             * @param {Array} words The data words to operate on.
  7332  	             * @param {number} offset The offset where the block starts.
  7333  	             *
  7334  	             * @example
  7335  	             *
  7336  	             *     mode.processBlock(data.words, offset);
  7337  	             */
  7338  	            processBlock: function (words, offset) {
  7339  	                // Shortcuts
  7340  	                var cipher = this._cipher;
  7341  	                var blockSize = cipher.blockSize;
  7342  
  7343  	                // Remember this block to use with next block
  7344  	                var thisBlock = words.slice(offset, offset + blockSize);
  7345  
  7346  	                // Decrypt and XOR
  7347  	                cipher.decryptBlock(words, offset);
  7348  	                xorBlock.call(this, words, offset, blockSize);
  7349  
  7350  	                // This block becomes the previous block
  7351  	                this._prevBlock = thisBlock;
  7352  	            }
  7353  	        });
  7354  
  7355  	        function xorBlock(words, offset, blockSize) {
  7356  	            // Shortcut
  7357  	            var iv = this._iv;
  7358  
  7359  	            // Choose mixing block
  7360  	            if (iv) {
  7361  	                var block = iv;
  7362  
  7363  	                // Remove IV for subsequent blocks
  7364  	                this._iv = undefined;
  7365  	            } else {
  7366  	                var block = this._prevBlock;
  7367  	            }
  7368  
  7369  	            // XOR blocks
  7370  	            for (var i = 0; i < blockSize; i++) {
  7371  	                words[offset + i] ^= block[i];
  7372  	            }
  7373  	        }
  7374  
  7375  	        return CBC;
  7376  	    }());
  7377  
  7378  	    /**
  7379  	     * Padding namespace.
  7380  	     */
  7381  	    var C_pad = C.pad = {};
  7382  
  7383  	    /**
  7384  	     * PKCS #5/7 padding strategy.
  7385  	     */
  7386  	    var Pkcs7 = C_pad.Pkcs7 = {
  7387  	        /**
  7388  	         * Pads data using the algorithm defined in PKCS #5/7.
  7389  	         *
  7390  	         * @param {WordArray} data The data to pad.
  7391  	         * @param {number} blockSize The multiple that the data should be padded to.
  7392  	         *
  7393  	         * @static
  7394  	         *
  7395  	         * @example
  7396  	         *
  7397  	         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
  7398  	         */
  7399  	        pad: function (data, blockSize) {
  7400  	            // Shortcut
  7401  	            var blockSizeBytes = blockSize * 4;
  7402  
  7403  	            // Count padding bytes
  7404  	            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
  7405  
  7406  	            // Create padding word
  7407  	            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
  7408  
  7409  	            // Create padding
  7410  	            var paddingWords = [];
  7411  	            for (var i = 0; i < nPaddingBytes; i += 4) {
  7412  	                paddingWords.push(paddingWord);
  7413  	            }
  7414  	            var padding = WordArray.create(paddingWords, nPaddingBytes);
  7415  
  7416  	            // Add padding
  7417  	            data.concat(padding);
  7418  	        },
  7419  
  7420  	        /**
  7421  	         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
  7422  	         *
  7423  	         * @param {WordArray} data The data to unpad.
  7424  	         *
  7425  	         * @static
  7426  	         *
  7427  	         * @example
  7428  	         *
  7429  	         *     CryptoJS.pad.Pkcs7.unpad(wordArray);
  7430  	         */
  7431  	        unpad: function (data) {
  7432  	            // Get number of padding bytes from last byte
  7433  	            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
  7434  
  7435  	            // Remove padding
  7436  	            data.sigBytes -= nPaddingBytes;
  7437  	        }
  7438  	    };
  7439  
  7440  	    /**
  7441  	     * Abstract base block cipher template.
  7442  	     *
  7443  	     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
  7444  	     */
  7445  	    var BlockCipher = C_lib.BlockCipher = Cipher.extend({
  7446  	        /**
  7447  	         * Configuration options.
  7448  	         *
  7449  	         * @property {Mode} mode The block mode to use. Default: CBC
  7450  	         * @property {Padding} padding The padding strategy to use. Default: Pkcs7
  7451  	         */
  7452  	        cfg: Cipher.cfg.extend({
  7453  	            mode: CBC,
  7454  	            padding: Pkcs7
  7455  	        }),
  7456  
  7457  	        reset: function () {
  7458  	            // Reset cipher
  7459  	            Cipher.reset.call(this);
  7460  
  7461  	            // Shortcuts
  7462  	            var cfg = this.cfg;
  7463  	            var iv = cfg.iv;
  7464  	            var mode = cfg.mode;
  7465  
  7466  	            // Reset block mode
  7467  	            if (this._xformMode == this._ENC_XFORM_MODE) {
  7468  	                var modeCreator = mode.createEncryptor;
  7469  	            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
  7470  	                var modeCreator = mode.createDecryptor;
  7471  
  7472  	                // Keep at least one block in the buffer for unpadding
  7473  	                this._minBufferSize = 1;
  7474  	            }
  7475  	            this._mode = modeCreator.call(mode, this, iv && iv.words);
  7476  	        },
  7477  
  7478  	        _doProcessBlock: function (words, offset) {
  7479  	            this._mode.processBlock(words, offset);
  7480  	        },
  7481  
  7482  	        _doFinalize: function () {
  7483  	            // Shortcut
  7484  	            var padding = this.cfg.padding;
  7485  
  7486  	            // Finalize
  7487  	            if (this._xformMode == this._ENC_XFORM_MODE) {
  7488  	                // Pad data
  7489  	                padding.pad(this._data, this.blockSize);
  7490  
  7491  	                // Process final blocks
  7492  	                var finalProcessedBlocks = this._process(!!'flush');
  7493  	            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
  7494  	                // Process final blocks
  7495  	                var finalProcessedBlocks = this._process(!!'flush');
  7496  
  7497  	                // Unpad data
  7498  	                padding.unpad(finalProcessedBlocks);
  7499  	            }
  7500  
  7501  	            return finalProcessedBlocks;
  7502  	        },
  7503  
  7504  	        blockSize: 128/32
  7505  	    });
  7506  
  7507  	    /**
  7508  	     * A collection of cipher parameters.
  7509  	     *
  7510  	     * @property {WordArray} ciphertext The raw ciphertext.
  7511  	     * @property {WordArray} key The key to this ciphertext.
  7512  	     * @property {WordArray} iv The IV used in the ciphering operation.
  7513  	     * @property {WordArray} salt The salt used with a key derivation function.
  7514  	     * @property {Cipher} algorithm The cipher algorithm.
  7515  	     * @property {Mode} mode The block mode used in the ciphering operation.
  7516  	     * @property {Padding} padding The padding scheme used in the ciphering operation.
  7517  	     * @property {number} blockSize The block size of the cipher.
  7518  	     * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
  7519  	     */
  7520  	    var CipherParams = C_lib.CipherParams = Base.extend({
  7521  	        /**
  7522  	         * Initializes a newly created cipher params object.
  7523  	         *
  7524  	         * @param {Object} cipherParams An object with any of the possible cipher parameters.
  7525  	         *
  7526  	         * @example
  7527  	         *
  7528  	         *     var cipherParams = CryptoJS.lib.CipherParams.create({
  7529  	         *         ciphertext: ciphertextWordArray,
  7530  	         *         key: keyWordArray,
  7531  	         *         iv: ivWordArray,
  7532  	         *         salt: saltWordArray,
  7533  	         *         algorithm: CryptoJS.algo.AES,
  7534  	         *         mode: CryptoJS.mode.CBC,
  7535  	         *         padding: CryptoJS.pad.PKCS7,
  7536  	         *         blockSize: 4,
  7537  	         *         formatter: CryptoJS.format.OpenSSL
  7538  	         *     });
  7539  	         */
  7540  	        init: function (cipherParams) {
  7541  	            this.mixIn(cipherParams);
  7542  	        },
  7543  
  7544  	        /**
  7545  	         * Converts this cipher params object to a string.
  7546  	         *
  7547  	         * @param {Format} formatter (Optional) The formatting strategy to use.
  7548  	         *
  7549  	         * @return {string} The stringified cipher params.
  7550  	         *
  7551  	         * @throws Error If neither the formatter nor the default formatter is set.
  7552  	         *
  7553  	         * @example
  7554  	         *
  7555  	         *     var string = cipherParams + '';
  7556  	         *     var string = cipherParams.toString();
  7557  	         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);
  7558  	         */
  7559  	        toString: function (formatter) {
  7560  	            return (formatter || this.formatter).stringify(this);
  7561  	        }
  7562  	    });
  7563  
  7564  	    /**
  7565  	     * Format namespace.
  7566  	     */
  7567  	    var C_format = C.format = {};
  7568  
  7569  	    /**
  7570  	     * OpenSSL formatting strategy.
  7571  	     */
  7572  	    var OpenSSLFormatter = C_format.OpenSSL = {
  7573  	        /**
  7574  	         * Converts a cipher params object to an OpenSSL-compatible string.
  7575  	         *
  7576  	         * @param {CipherParams} cipherParams The cipher params object.
  7577  	         *
  7578  	         * @return {string} The OpenSSL-compatible string.
  7579  	         *
  7580  	         * @static
  7581  	         *
  7582  	         * @example
  7583  	         *
  7584  	         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
  7585  	         */
  7586  	        stringify: function (cipherParams) {
  7587  	            // Shortcuts
  7588  	            var ciphertext = cipherParams.ciphertext;
  7589  	            var salt = cipherParams.salt;
  7590  
  7591  	            // Format
  7592  	            if (salt) {
  7593  	                var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
  7594  	            } else {
  7595  	                var wordArray = ciphertext;
  7596  	            }
  7597  
  7598  	            return wordArray.toString(Base64);
  7599  	        },
  7600  
  7601  	        /**
  7602  	         * Converts an OpenSSL-compatible string to a cipher params object.
  7603  	         *
  7604  	         * @param {string} openSSLStr The OpenSSL-compatible string.
  7605  	         *
  7606  	         * @return {CipherParams} The cipher params object.
  7607  	         *
  7608  	         * @static
  7609  	         *
  7610  	         * @example
  7611  	         *
  7612  	         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
  7613  	         */
  7614  	        parse: function (openSSLStr) {
  7615  	            // Parse base64
  7616  	            var ciphertext = Base64.parse(openSSLStr);
  7617  
  7618  	            // Shortcut
  7619  	            var ciphertextWords = ciphertext.words;
  7620  
  7621  	            // Test for salt
  7622  	            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
  7623  	                // Extract salt
  7624  	                var salt = WordArray.create(ciphertextWords.slice(2, 4));
  7625  
  7626  	                // Remove salt from ciphertext
  7627  	                ciphertextWords.splice(0, 4);
  7628  	                ciphertext.sigBytes -= 16;
  7629  	            }
  7630  
  7631  	            return CipherParams.create({ ciphertext: ciphertext, salt: salt });
  7632  	        }
  7633  	    };
  7634  
  7635  	    /**
  7636  	     * A cipher wrapper that returns ciphertext as a serializable cipher params object.
  7637  	     */
  7638  	    var SerializableCipher = C_lib.SerializableCipher = Base.extend({
  7639  	        /**
  7640  	         * Configuration options.
  7641  	         *
  7642  	         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
  7643  	         */
  7644  	        cfg: Base.extend({
  7645  	            format: OpenSSLFormatter
  7646  	        }),
  7647  
  7648  	        /**
  7649  	         * Encrypts a message.
  7650  	         *
  7651  	         * @param {Cipher} cipher The cipher algorithm to use.
  7652  	         * @param {WordArray|string} message The message to encrypt.
  7653  	         * @param {WordArray} key The key.
  7654  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7655  	         *
  7656  	         * @return {CipherParams} A cipher params object.
  7657  	         *
  7658  	         * @static
  7659  	         *
  7660  	         * @example
  7661  	         *
  7662  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
  7663  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
  7664  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
  7665  	         */
  7666  	        encrypt: function (cipher, message, key, cfg) {
  7667  	            // Apply config defaults
  7668  	            cfg = this.cfg.extend(cfg);
  7669  
  7670  	            // Encrypt
  7671  	            var encryptor = cipher.createEncryptor(key, cfg);
  7672  	            var ciphertext = encryptor.finalize(message);
  7673  
  7674  	            // Shortcut
  7675  	            var cipherCfg = encryptor.cfg;
  7676  
  7677  	            // Create and return serializable cipher params
  7678  	            return CipherParams.create({
  7679  	                ciphertext: ciphertext,
  7680  	                key: key,
  7681  	                iv: cipherCfg.iv,
  7682  	                algorithm: cipher,
  7683  	                mode: cipherCfg.mode,
  7684  	                padding: cipherCfg.padding,
  7685  	                blockSize: cipher.blockSize,
  7686  	                formatter: cfg.format
  7687  	            });
  7688  	        },
  7689  
  7690  	        /**
  7691  	         * Decrypts serialized ciphertext.
  7692  	         *
  7693  	         * @param {Cipher} cipher The cipher algorithm to use.
  7694  	         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
  7695  	         * @param {WordArray} key The key.
  7696  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7697  	         *
  7698  	         * @return {WordArray} The plaintext.
  7699  	         *
  7700  	         * @static
  7701  	         *
  7702  	         * @example
  7703  	         *
  7704  	         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
  7705  	         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
  7706  	         */
  7707  	        decrypt: function (cipher, ciphertext, key, cfg) {
  7708  	            // Apply config defaults
  7709  	            cfg = this.cfg.extend(cfg);
  7710  
  7711  	            // Convert string to CipherParams
  7712  	            ciphertext = this._parse(ciphertext, cfg.format);
  7713  
  7714  	            // Decrypt
  7715  	            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
  7716  
  7717  	            return plaintext;
  7718  	        },
  7719  
  7720  	        /**
  7721  	         * Converts serialized ciphertext to CipherParams,
  7722  	         * else assumed CipherParams already and returns ciphertext unchanged.
  7723  	         *
  7724  	         * @param {CipherParams|string} ciphertext The ciphertext.
  7725  	         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
  7726  	         *
  7727  	         * @return {CipherParams} The unserialized ciphertext.
  7728  	         *
  7729  	         * @static
  7730  	         *
  7731  	         * @example
  7732  	         *
  7733  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
  7734  	         */
  7735  	        _parse: function (ciphertext, format) {
  7736  	            if (typeof ciphertext == 'string') {
  7737  	                return format.parse(ciphertext, this);
  7738  	            } else {
  7739  	                return ciphertext;
  7740  	            }
  7741  	        }
  7742  	    });
  7743  
  7744  	    /**
  7745  	     * Key derivation function namespace.
  7746  	     */
  7747  	    var C_kdf = C.kdf = {};
  7748  
  7749  	    /**
  7750  	     * OpenSSL key derivation function.
  7751  	     */
  7752  	    var OpenSSLKdf = C_kdf.OpenSSL = {
  7753  	        /**
  7754  	         * Derives a key and IV from a password.
  7755  	         *
  7756  	         * @param {string} password The password to derive from.
  7757  	         * @param {number} keySize The size in words of the key to generate.
  7758  	         * @param {number} ivSize The size in words of the IV to generate.
  7759  	         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
  7760  	         *
  7761  	         * @return {CipherParams} A cipher params object with the key, IV, and salt.
  7762  	         *
  7763  	         * @static
  7764  	         *
  7765  	         * @example
  7766  	         *
  7767  	         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
  7768  	         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
  7769  	         */
  7770  	        execute: function (password, keySize, ivSize, salt) {
  7771  	            // Generate random salt
  7772  	            if (!salt) {
  7773  	                salt = WordArray.random(64/8);
  7774  	            }
  7775  
  7776  	            // Derive key and IV
  7777  	            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
  7778  
  7779  	            // Separate key and IV
  7780  	            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
  7781  	            key.sigBytes = keySize * 4;
  7782  
  7783  	            // Return params
  7784  	            return CipherParams.create({ key: key, iv: iv, salt: salt });
  7785  	        }
  7786  	    };
  7787  
  7788  	    /**
  7789  	     * A serializable cipher wrapper that derives the key from a password,
  7790  	     * and returns ciphertext as a serializable cipher params object.
  7791  	     */
  7792  	    var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
  7793  	        /**
  7794  	         * Configuration options.
  7795  	         *
  7796  	         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
  7797  	         */
  7798  	        cfg: SerializableCipher.cfg.extend({
  7799  	            kdf: OpenSSLKdf
  7800  	        }),
  7801  
  7802  	        /**
  7803  	         * Encrypts a message using a password.
  7804  	         *
  7805  	         * @param {Cipher} cipher The cipher algorithm to use.
  7806  	         * @param {WordArray|string} message The message to encrypt.
  7807  	         * @param {string} password The password.
  7808  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7809  	         *
  7810  	         * @return {CipherParams} A cipher params object.
  7811  	         *
  7812  	         * @static
  7813  	         *
  7814  	         * @example
  7815  	         *
  7816  	         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
  7817  	         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
  7818  	         */
  7819  	        encrypt: function (cipher, message, password, cfg) {
  7820  	            // Apply config defaults
  7821  	            cfg = this.cfg.extend(cfg);
  7822  
  7823  	            // Derive key and other params
  7824  	            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
  7825  
  7826  	            // Add IV to config
  7827  	            cfg.iv = derivedParams.iv;
  7828  
  7829  	            // Encrypt
  7830  	            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
  7831  
  7832  	            // Mix in derived params
  7833  	            ciphertext.mixIn(derivedParams);
  7834  
  7835  	            return ciphertext;
  7836  	        },
  7837  
  7838  	        /**
  7839  	         * Decrypts serialized ciphertext using a password.
  7840  	         *
  7841  	         * @param {Cipher} cipher The cipher algorithm to use.
  7842  	         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
  7843  	         * @param {string} password The password.
  7844  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  7845  	         *
  7846  	         * @return {WordArray} The plaintext.
  7847  	         *
  7848  	         * @static
  7849  	         *
  7850  	         * @example
  7851  	         *
  7852  	         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
  7853  	         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
  7854  	         */
  7855  	        decrypt: function (cipher, ciphertext, password, cfg) {
  7856  	            // Apply config defaults
  7857  	            cfg = this.cfg.extend(cfg);
  7858  
  7859  	            // Convert string to CipherParams
  7860  	            ciphertext = this._parse(ciphertext, cfg.format);
  7861  
  7862  	            // Derive key and other params
  7863  	            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
  7864  
  7865  	            // Add IV to config
  7866  	            cfg.iv = derivedParams.iv;
  7867  
  7868  	            // Decrypt
  7869  	            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
  7870  
  7871  	            return plaintext;
  7872  	        }
  7873  	    });
  7874  	}());
  7875  
  7876  
  7877  }));
  7878  },{"./core":53}],53:[function(require,module,exports){
  7879  ;(function (root, factory) {
  7880  	if (typeof exports === "object") {
  7881  		// CommonJS
  7882  		module.exports = exports = factory();
  7883  	}
  7884  	else if (typeof define === "function" && define.amd) {
  7885  		// AMD
  7886  		define([], factory);
  7887  	}
  7888  	else {
  7889  		// Global (browser)
  7890  		root.CryptoJS = factory();
  7891  	}
  7892  }(this, function () {
  7893  
  7894  	/**
  7895  	 * CryptoJS core components.
  7896  	 */
  7897  	var CryptoJS = CryptoJS || (function (Math, undefined) {
  7898  	    /*
  7899  	     * Local polyfil of Object.create
  7900  	     */
  7901  	    var create = Object.create || (function () {
  7902  	        function F() {};
  7903  
  7904  	        return function (obj) {
  7905  	            var subtype;
  7906  
  7907  	            F.prototype = obj;
  7908  
  7909  	            subtype = new F();
  7910  
  7911  	            F.prototype = null;
  7912  
  7913  	            return subtype;
  7914  	        };
  7915  	    }())
  7916  
  7917  	    /**
  7918  	     * CryptoJS namespace.
  7919  	     */
  7920  	    var C = {};
  7921  
  7922  	    /**
  7923  	     * Library namespace.
  7924  	     */
  7925  	    var C_lib = C.lib = {};
  7926  
  7927  	    /**
  7928  	     * Base object for prototypal inheritance.
  7929  	     */
  7930  	    var Base = C_lib.Base = (function () {
  7931  
  7932  
  7933  	        return {
  7934  	            /**
  7935  	             * Creates a new object that inherits from this object.
  7936  	             *
  7937  	             * @param {Object} overrides Properties to copy into the new object.
  7938  	             *
  7939  	             * @return {Object} The new object.
  7940  	             *
  7941  	             * @static
  7942  	             *
  7943  	             * @example
  7944  	             *
  7945  	             *     var MyType = CryptoJS.lib.Base.extend({
  7946  	             *         field: 'value',
  7947  	             *
  7948  	             *         method: function () {
  7949  	             *         }
  7950  	             *     });
  7951  	             */
  7952  	            extend: function (overrides) {
  7953  	                // Spawn
  7954  	                var subtype = create(this);
  7955  
  7956  	                // Augment
  7957  	                if (overrides) {
  7958  	                    subtype.mixIn(overrides);
  7959  	                }
  7960  
  7961  	                // Create default initializer
  7962  	                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
  7963  	                    subtype.init = function () {
  7964  	                        subtype.$super.init.apply(this, arguments);
  7965  	                    };
  7966  	                }
  7967  
  7968  	                // Initializer's prototype is the subtype object
  7969  	                subtype.init.prototype = subtype;
  7970  
  7971  	                // Reference supertype
  7972  	                subtype.$super = this;
  7973  
  7974  	                return subtype;
  7975  	            },
  7976  
  7977  	            /**
  7978  	             * Extends this object and runs the init method.
  7979  	             * Arguments to create() will be passed to init().
  7980  	             *
  7981  	             * @return {Object} The new object.
  7982  	             *
  7983  	             * @static
  7984  	             *
  7985  	             * @example
  7986  	             *
  7987  	             *     var instance = MyType.create();
  7988  	             */
  7989  	            create: function () {
  7990  	                var instance = this.extend();
  7991  	                instance.init.apply(instance, arguments);
  7992  
  7993  	                return instance;
  7994  	            },
  7995  
  7996  	            /**
  7997  	             * Initializes a newly created object.
  7998  	             * Override this method to add some logic when your objects are created.
  7999  	             *
  8000  	             * @example
  8001  	             *
  8002  	             *     var MyType = CryptoJS.lib.Base.extend({
  8003  	             *         init: function () {
  8004  	             *             // ...
  8005  	             *         }
  8006  	             *     });
  8007  	             */
  8008  	            init: function () {
  8009  	            },
  8010  
  8011  	            /**
  8012  	             * Copies properties into this object.
  8013  	             *
  8014  	             * @param {Object} properties The properties to mix in.
  8015  	             *
  8016  	             * @example
  8017  	             *
  8018  	             *     MyType.mixIn({
  8019  	             *         field: 'value'
  8020  	             *     });
  8021  	             */
  8022  	            mixIn: function (properties) {
  8023  	                for (var propertyName in properties) {
  8024  	                    if (properties.hasOwnProperty(propertyName)) {
  8025  	                        this[propertyName] = properties[propertyName];
  8026  	                    }
  8027  	                }
  8028  
  8029  	                // IE won't copy toString using the loop above
  8030  	                if (properties.hasOwnProperty('toString')) {
  8031  	                    this.toString = properties.toString;
  8032  	                }
  8033  	            },
  8034  
  8035  	            /**
  8036  	             * Creates a copy of this object.
  8037  	             *
  8038  	             * @return {Object} The clone.
  8039  	             *
  8040  	             * @example
  8041  	             *
  8042  	             *     var clone = instance.clone();
  8043  	             */
  8044  	            clone: function () {
  8045  	                return this.init.prototype.extend(this);
  8046  	            }
  8047  	        };
  8048  	    }());
  8049  
  8050  	    /**
  8051  	     * An array of 32-bit words.
  8052  	     *
  8053  	     * @property {Array} words The array of 32-bit words.
  8054  	     * @property {number} sigBytes The number of significant bytes in this word array.
  8055  	     */
  8056  	    var WordArray = C_lib.WordArray = Base.extend({
  8057  	        /**
  8058  	         * Initializes a newly created word array.
  8059  	         *
  8060  	         * @param {Array} words (Optional) An array of 32-bit words.
  8061  	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
  8062  	         *
  8063  	         * @example
  8064  	         *
  8065  	         *     var wordArray = CryptoJS.lib.WordArray.create();
  8066  	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
  8067  	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
  8068  	         */
  8069  	        init: function (words, sigBytes) {
  8070  	            words = this.words = words || [];
  8071  
  8072  	            if (sigBytes != undefined) {
  8073  	                this.sigBytes = sigBytes;
  8074  	            } else {
  8075  	                this.sigBytes = words.length * 4;
  8076  	            }
  8077  	        },
  8078  
  8079  	        /**
  8080  	         * Converts this word array to a string.
  8081  	         *
  8082  	         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
  8083  	         *
  8084  	         * @return {string} The stringified word array.
  8085  	         *
  8086  	         * @example
  8087  	         *
  8088  	         *     var string = wordArray + '';
  8089  	         *     var string = wordArray.toString();
  8090  	         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
  8091  	         */
  8092  	        toString: function (encoder) {
  8093  	            return (encoder || Hex).stringify(this);
  8094  	        },
  8095  
  8096  	        /**
  8097  	         * Concatenates a word array to this word array.
  8098  	         *
  8099  	         * @param {WordArray} wordArray The word array to append.
  8100  	         *
  8101  	         * @return {WordArray} This word array.
  8102  	         *
  8103  	         * @example
  8104  	         *
  8105  	         *     wordArray1.concat(wordArray2);
  8106  	         */
  8107  	        concat: function (wordArray) {
  8108  	            // Shortcuts
  8109  	            var thisWords = this.words;
  8110  	            var thatWords = wordArray.words;
  8111  	            var thisSigBytes = this.sigBytes;
  8112  	            var thatSigBytes = wordArray.sigBytes;
  8113  
  8114  	            // Clamp excess bits
  8115  	            this.clamp();
  8116  
  8117  	            // Concat
  8118  	            if (thisSigBytes % 4) {
  8119  	                // Copy one byte at a time
  8120  	                for (var i = 0; i < thatSigBytes; i++) {
  8121  	                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
  8122  	                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
  8123  	                }
  8124  	            } else {
  8125  	                // Copy one word at a time
  8126  	                for (var i = 0; i < thatSigBytes; i += 4) {
  8127  	                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
  8128  	                }
  8129  	            }
  8130  	            this.sigBytes += thatSigBytes;
  8131  
  8132  	            // Chainable
  8133  	            return this;
  8134  	        },
  8135  
  8136  	        /**
  8137  	         * Removes insignificant bits.
  8138  	         *
  8139  	         * @example
  8140  	         *
  8141  	         *     wordArray.clamp();
  8142  	         */
  8143  	        clamp: function () {
  8144  	            // Shortcuts
  8145  	            var words = this.words;
  8146  	            var sigBytes = this.sigBytes;
  8147  
  8148  	            // Clamp
  8149  	            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
  8150  	            words.length = Math.ceil(sigBytes / 4);
  8151  	        },
  8152  
  8153  	        /**
  8154  	         * Creates a copy of this word array.
  8155  	         *
  8156  	         * @return {WordArray} The clone.
  8157  	         *
  8158  	         * @example
  8159  	         *
  8160  	         *     var clone = wordArray.clone();
  8161  	         */
  8162  	        clone: function () {
  8163  	            var clone = Base.clone.call(this);
  8164  	            clone.words = this.words.slice(0);
  8165  
  8166  	            return clone;
  8167  	        },
  8168  
  8169  	        /**
  8170  	         * Creates a word array filled with random bytes.
  8171  	         *
  8172  	         * @param {number} nBytes The number of random bytes to generate.
  8173  	         *
  8174  	         * @return {WordArray} The random word array.
  8175  	         *
  8176  	         * @static
  8177  	         *
  8178  	         * @example
  8179  	         *
  8180  	         *     var wordArray = CryptoJS.lib.WordArray.random(16);
  8181  	         */
  8182  	        random: function (nBytes) {
  8183  	            var words = [];
  8184  
  8185  	            var r = (function (m_w) {
  8186  	                var m_w = m_w;
  8187  	                var m_z = 0x3ade68b1;
  8188  	                var mask = 0xffffffff;
  8189  
  8190  	                return function () {
  8191  	                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
  8192  	                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
  8193  	                    var result = ((m_z << 0x10) + m_w) & mask;
  8194  	                    result /= 0x100000000;
  8195  	                    result += 0.5;
  8196  	                    return result * (Math.random() > .5 ? 1 : -1);
  8197  	                }
  8198  	            });
  8199  
  8200  	            for (var i = 0, rcache; i < nBytes; i += 4) {
  8201  	                var _r = r((rcache || Math.random()) * 0x100000000);
  8202  
  8203  	                rcache = _r() * 0x3ade67b7;
  8204  	                words.push((_r() * 0x100000000) | 0);
  8205  	            }
  8206  
  8207  	            return new WordArray.init(words, nBytes);
  8208  	        }
  8209  	    });
  8210  
  8211  	    /**
  8212  	     * Encoder namespace.
  8213  	     */
  8214  	    var C_enc = C.enc = {};
  8215  
  8216  	    /**
  8217  	     * Hex encoding strategy.
  8218  	     */
  8219  	    var Hex = C_enc.Hex = {
  8220  	        /**
  8221  	         * Converts a word array to a hex string.
  8222  	         *
  8223  	         * @param {WordArray} wordArray The word array.
  8224  	         *
  8225  	         * @return {string} The hex string.
  8226  	         *
  8227  	         * @static
  8228  	         *
  8229  	         * @example
  8230  	         *
  8231  	         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
  8232  	         */
  8233  	        stringify: function (wordArray) {
  8234  	            // Shortcuts
  8235  	            var words = wordArray.words;
  8236  	            var sigBytes = wordArray.sigBytes;
  8237  
  8238  	            // Convert
  8239  	            var hexChars = [];
  8240  	            for (var i = 0; i < sigBytes; i++) {
  8241  	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
  8242  	                hexChars.push((bite >>> 4).toString(16));
  8243  	                hexChars.push((bite & 0x0f).toString(16));
  8244  	            }
  8245  
  8246  	            return hexChars.join('');
  8247  	        },
  8248  
  8249  	        /**
  8250  	         * Converts a hex string to a word array.
  8251  	         *
  8252  	         * @param {string} hexStr The hex string.
  8253  	         *
  8254  	         * @return {WordArray} The word array.
  8255  	         *
  8256  	         * @static
  8257  	         *
  8258  	         * @example
  8259  	         *
  8260  	         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
  8261  	         */
  8262  	        parse: function (hexStr) {
  8263  	            // Shortcut
  8264  	            var hexStrLength = hexStr.length;
  8265  
  8266  	            // Convert
  8267  	            var words = [];
  8268  	            for (var i = 0; i < hexStrLength; i += 2) {
  8269  	                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
  8270  	            }
  8271  
  8272  	            return new WordArray.init(words, hexStrLength / 2);
  8273  	        }
  8274  	    };
  8275  
  8276  	    /**
  8277  	     * Latin1 encoding strategy.
  8278  	     */
  8279  	    var Latin1 = C_enc.Latin1 = {
  8280  	        /**
  8281  	         * Converts a word array to a Latin1 string.
  8282  	         *
  8283  	         * @param {WordArray} wordArray The word array.
  8284  	         *
  8285  	         * @return {string} The Latin1 string.
  8286  	         *
  8287  	         * @static
  8288  	         *
  8289  	         * @example
  8290  	         *
  8291  	         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
  8292  	         */
  8293  	        stringify: function (wordArray) {
  8294  	            // Shortcuts
  8295  	            var words = wordArray.words;
  8296  	            var sigBytes = wordArray.sigBytes;
  8297  
  8298  	            // Convert
  8299  	            var latin1Chars = [];
  8300  	            for (var i = 0; i < sigBytes; i++) {
  8301  	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
  8302  	                latin1Chars.push(String.fromCharCode(bite));
  8303  	            }
  8304  
  8305  	            return latin1Chars.join('');
  8306  	        },
  8307  
  8308  	        /**
  8309  	         * Converts a Latin1 string to a word array.
  8310  	         *
  8311  	         * @param {string} latin1Str The Latin1 string.
  8312  	         *
  8313  	         * @return {WordArray} The word array.
  8314  	         *
  8315  	         * @static
  8316  	         *
  8317  	         * @example
  8318  	         *
  8319  	         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
  8320  	         */
  8321  	        parse: function (latin1Str) {
  8322  	            // Shortcut
  8323  	            var latin1StrLength = latin1Str.length;
  8324  
  8325  	            // Convert
  8326  	            var words = [];
  8327  	            for (var i = 0; i < latin1StrLength; i++) {
  8328  	                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
  8329  	            }
  8330  
  8331  	            return new WordArray.init(words, latin1StrLength);
  8332  	        }
  8333  	    };
  8334  
  8335  	    /**
  8336  	     * UTF-8 encoding strategy.
  8337  	     */
  8338  	    var Utf8 = C_enc.Utf8 = {
  8339  	        /**
  8340  	         * Converts a word array to a UTF-8 string.
  8341  	         *
  8342  	         * @param {WordArray} wordArray The word array.
  8343  	         *
  8344  	         * @return {string} The UTF-8 string.
  8345  	         *
  8346  	         * @static
  8347  	         *
  8348  	         * @example
  8349  	         *
  8350  	         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
  8351  	         */
  8352  	        stringify: function (wordArray) {
  8353  	            try {
  8354  	                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
  8355  	            } catch (e) {
  8356  	                throw new Error('Malformed UTF-8 data');
  8357  	            }
  8358  	        },
  8359  
  8360  	        /**
  8361  	         * Converts a UTF-8 string to a word array.
  8362  	         *
  8363  	         * @param {string} utf8Str The UTF-8 string.
  8364  	         *
  8365  	         * @return {WordArray} The word array.
  8366  	         *
  8367  	         * @static
  8368  	         *
  8369  	         * @example
  8370  	         *
  8371  	         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
  8372  	         */
  8373  	        parse: function (utf8Str) {
  8374  	            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
  8375  	        }
  8376  	    };
  8377  
  8378  	    /**
  8379  	     * Abstract buffered block algorithm template.
  8380  	     *
  8381  	     * The property blockSize must be implemented in a concrete subtype.
  8382  	     *
  8383  	     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
  8384  	     */
  8385  	    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
  8386  	        /**
  8387  	         * Resets this block algorithm's data buffer to its initial state.
  8388  	         *
  8389  	         * @example
  8390  	         *
  8391  	         *     bufferedBlockAlgorithm.reset();
  8392  	         */
  8393  	        reset: function () {
  8394  	            // Initial values
  8395  	            this._data = new WordArray.init();
  8396  	            this._nDataBytes = 0;
  8397  	        },
  8398  
  8399  	        /**
  8400  	         * Adds new data to this block algorithm's buffer.
  8401  	         *
  8402  	         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
  8403  	         *
  8404  	         * @example
  8405  	         *
  8406  	         *     bufferedBlockAlgorithm._append('data');
  8407  	         *     bufferedBlockAlgorithm._append(wordArray);
  8408  	         */
  8409  	        _append: function (data) {
  8410  	            // Convert string to WordArray, else assume WordArray already
  8411  	            if (typeof data == 'string') {
  8412  	                data = Utf8.parse(data);
  8413  	            }
  8414  
  8415  	            // Append
  8416  	            this._data.concat(data);
  8417  	            this._nDataBytes += data.sigBytes;
  8418  	        },
  8419  
  8420  	        /**
  8421  	         * Processes available data blocks.
  8422  	         *
  8423  	         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
  8424  	         *
  8425  	         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
  8426  	         *
  8427  	         * @return {WordArray} The processed data.
  8428  	         *
  8429  	         * @example
  8430  	         *
  8431  	         *     var processedData = bufferedBlockAlgorithm._process();
  8432  	         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
  8433  	         */
  8434  	        _process: function (doFlush) {
  8435  	            // Shortcuts
  8436  	            var data = this._data;
  8437  	            var dataWords = data.words;
  8438  	            var dataSigBytes = data.sigBytes;
  8439  	            var blockSize = this.blockSize;
  8440  	            var blockSizeBytes = blockSize * 4;
  8441  
  8442  	            // Count blocks ready
  8443  	            var nBlocksReady = dataSigBytes / blockSizeBytes;
  8444  	            if (doFlush) {
  8445  	                // Round up to include partial blocks
  8446  	                nBlocksReady = Math.ceil(nBlocksReady);
  8447  	            } else {
  8448  	                // Round down to include only full blocks,
  8449  	                // less the number of blocks that must remain in the buffer
  8450  	                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
  8451  	            }
  8452  
  8453  	            // Count words ready
  8454  	            var nWordsReady = nBlocksReady * blockSize;
  8455  
  8456  	            // Count bytes ready
  8457  	            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
  8458  
  8459  	            // Process blocks
  8460  	            if (nWordsReady) {
  8461  	                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
  8462  	                    // Perform concrete-algorithm logic
  8463  	                    this._doProcessBlock(dataWords, offset);
  8464  	                }
  8465  
  8466  	                // Remove processed words
  8467  	                var processedWords = dataWords.splice(0, nWordsReady);
  8468  	                data.sigBytes -= nBytesReady;
  8469  	            }
  8470  
  8471  	            // Return processed words
  8472  	            return new WordArray.init(processedWords, nBytesReady);
  8473  	        },
  8474  
  8475  	        /**
  8476  	         * Creates a copy of this object.
  8477  	         *
  8478  	         * @return {Object} The clone.
  8479  	         *
  8480  	         * @example
  8481  	         *
  8482  	         *     var clone = bufferedBlockAlgorithm.clone();
  8483  	         */
  8484  	        clone: function () {
  8485  	            var clone = Base.clone.call(this);
  8486  	            clone._data = this._data.clone();
  8487  
  8488  	            return clone;
  8489  	        },
  8490  
  8491  	        _minBufferSize: 0
  8492  	    });
  8493  
  8494  	    /**
  8495  	     * Abstract hasher template.
  8496  	     *
  8497  	     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
  8498  	     */
  8499  	    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
  8500  	        /**
  8501  	         * Configuration options.
  8502  	         */
  8503  	        cfg: Base.extend(),
  8504  
  8505  	        /**
  8506  	         * Initializes a newly created hasher.
  8507  	         *
  8508  	         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
  8509  	         *
  8510  	         * @example
  8511  	         *
  8512  	         *     var hasher = CryptoJS.algo.SHA256.create();
  8513  	         */
  8514  	        init: function (cfg) {
  8515  	            // Apply config defaults
  8516  	            this.cfg = this.cfg.extend(cfg);
  8517  
  8518  	            // Set initial values
  8519  	            this.reset();
  8520  	        },
  8521  
  8522  	        /**
  8523  	         * Resets this hasher to its initial state.
  8524  	         *
  8525  	         * @example
  8526  	         *
  8527  	         *     hasher.reset();
  8528  	         */
  8529  	        reset: function () {
  8530  	            // Reset data buffer
  8531  	            BufferedBlockAlgorithm.reset.call(this);
  8532  
  8533  	            // Perform concrete-hasher logic
  8534  	            this._doReset();
  8535  	        },
  8536  
  8537  	        /**
  8538  	         * Updates this hasher with a message.
  8539  	         *
  8540  	         * @param {WordArray|string} messageUpdate The message to append.
  8541  	         *
  8542  	         * @return {Hasher} This hasher.
  8543  	         *
  8544  	         * @example
  8545  	         *
  8546  	         *     hasher.update('message');
  8547  	         *     hasher.update(wordArray);
  8548  	         */
  8549  	        update: function (messageUpdate) {
  8550  	            // Append
  8551  	            this._append(messageUpdate);
  8552  
  8553  	            // Update the hash
  8554  	            this._process();
  8555  
  8556  	            // Chainable
  8557  	            return this;
  8558  	        },
  8559  
  8560  	        /**
  8561  	         * Finalizes the hash computation.
  8562  	         * Note that the finalize operation is effectively a destructive, read-once operation.
  8563  	         *
  8564  	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
  8565  	         *
  8566  	         * @return {WordArray} The hash.
  8567  	         *
  8568  	         * @example
  8569  	         *
  8570  	         *     var hash = hasher.finalize();
  8571  	         *     var hash = hasher.finalize('message');
  8572  	         *     var hash = hasher.finalize(wordArray);
  8573  	         */
  8574  	        finalize: function (messageUpdate) {
  8575  	            // Final message update
  8576  	            if (messageUpdate) {
  8577  	                this._append(messageUpdate);
  8578  	            }
  8579  
  8580  	            // Perform concrete-hasher logic
  8581  	            var hash = this._doFinalize();
  8582  
  8583  	            return hash;
  8584  	        },
  8585  
  8586  	        blockSize: 512/32,
  8587  
  8588  	        /**
  8589  	         * Creates a shortcut function to a hasher's object interface.
  8590  	         *
  8591  	         * @param {Hasher} hasher The hasher to create a helper for.
  8592  	         *
  8593  	         * @return {Function} The shortcut function.
  8594  	         *
  8595  	         * @static
  8596  	         *
  8597  	         * @example
  8598  	         *
  8599  	         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
  8600  	         */
  8601  	        _createHelper: function (hasher) {
  8602  	            return function (message, cfg) {
  8603  	                return new hasher.init(cfg).finalize(message);
  8604  	            };
  8605  	        },
  8606  
  8607  	        /**
  8608  	         * Creates a shortcut function to the HMAC's object interface.
  8609  	         *
  8610  	         * @param {Hasher} hasher The hasher to use in this HMAC helper.
  8611  	         *
  8612  	         * @return {Function} The shortcut function.
  8613  	         *
  8614  	         * @static
  8615  	         *
  8616  	         * @example
  8617  	         *
  8618  	         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
  8619  	         */
  8620  	        _createHmacHelper: function (hasher) {
  8621  	            return function (message, key) {
  8622  	                return new C_algo.HMAC.init(hasher, key).finalize(message);
  8623  	            };
  8624  	        }
  8625  	    });
  8626  
  8627  	    /**
  8628  	     * Algorithm namespace.
  8629  	     */
  8630  	    var C_algo = C.algo = {};
  8631  
  8632  	    return C;
  8633  	}(Math));
  8634  
  8635  
  8636  	return CryptoJS;
  8637  
  8638  }));
  8639  },{}],54:[function(require,module,exports){
  8640  ;(function (root, factory) {
  8641  	if (typeof exports === "object") {
  8642  		// CommonJS
  8643  		module.exports = exports = factory(require("./core"));
  8644  	}
  8645  	else if (typeof define === "function" && define.amd) {
  8646  		// AMD
  8647  		define(["./core"], factory);
  8648  	}
  8649  	else {
  8650  		// Global (browser)
  8651  		factory(root.CryptoJS);
  8652  	}
  8653  }(this, function (CryptoJS) {
  8654  
  8655  	(function () {
  8656  	    // Shortcuts
  8657  	    var C = CryptoJS;
  8658  	    var C_lib = C.lib;
  8659  	    var WordArray = C_lib.WordArray;
  8660  	    var C_enc = C.enc;
  8661  
  8662  	    /**
  8663  	     * Base64 encoding strategy.
  8664  	     */
  8665  	    var Base64 = C_enc.Base64 = {
  8666  	        /**
  8667  	         * Converts a word array to a Base64 string.
  8668  	         *
  8669  	         * @param {WordArray} wordArray The word array.
  8670  	         *
  8671  	         * @return {string} The Base64 string.
  8672  	         *
  8673  	         * @static
  8674  	         *
  8675  	         * @example
  8676  	         *
  8677  	         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
  8678  	         */
  8679  	        stringify: function (wordArray) {
  8680  	            // Shortcuts
  8681  	            var words = wordArray.words;
  8682  	            var sigBytes = wordArray.sigBytes;
  8683  	            var map = this._map;
  8684  
  8685  	            // Clamp excess bits
  8686  	            wordArray.clamp();
  8687  
  8688  	            // Convert
  8689  	            var base64Chars = [];
  8690  	            for (var i = 0; i < sigBytes; i += 3) {
  8691  	                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
  8692  	                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
  8693  	                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
  8694  
  8695  	                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
  8696  
  8697  	                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
  8698  	                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
  8699  	                }
  8700  	            }
  8701  
  8702  	            // Add padding
  8703  	            var paddingChar = map.charAt(64);
  8704  	            if (paddingChar) {
  8705  	                while (base64Chars.length % 4) {
  8706  	                    base64Chars.push(paddingChar);
  8707  	                }
  8708  	            }
  8709  
  8710  	            return base64Chars.join('');
  8711  	        },
  8712  
  8713  	        /**
  8714  	         * Converts a Base64 string to a word array.
  8715  	         *
  8716  	         * @param {string} base64Str The Base64 string.
  8717  	         *
  8718  	         * @return {WordArray} The word array.
  8719  	         *
  8720  	         * @static
  8721  	         *
  8722  	         * @example
  8723  	         *
  8724  	         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
  8725  	         */
  8726  	        parse: function (base64Str) {
  8727  	            // Shortcuts
  8728  	            var base64StrLength = base64Str.length;
  8729  	            var map = this._map;
  8730  	            var reverseMap = this._reverseMap;
  8731  
  8732  	            if (!reverseMap) {
  8733  	                    reverseMap = this._reverseMap = [];
  8734  	                    for (var j = 0; j < map.length; j++) {
  8735  	                        reverseMap[map.charCodeAt(j)] = j;
  8736  	                    }
  8737  	            }
  8738  
  8739  	            // Ignore padding
  8740  	            var paddingChar = map.charAt(64);
  8741  	            if (paddingChar) {
  8742  	                var paddingIndex = base64Str.indexOf(paddingChar);
  8743  	                if (paddingIndex !== -1) {
  8744  	                    base64StrLength = paddingIndex;
  8745  	                }
  8746  	            }
  8747  
  8748  	            // Convert
  8749  	            return parseLoop(base64Str, base64StrLength, reverseMap);
  8750  
  8751  	        },
  8752  
  8753  	        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  8754  	    };
  8755  
  8756  	    function parseLoop(base64Str, base64StrLength, reverseMap) {
  8757  	      var words = [];
  8758  	      var nBytes = 0;
  8759  	      for (var i = 0; i < base64StrLength; i++) {
  8760  	          if (i % 4) {
  8761  	              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
  8762  	              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
  8763  	              words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
  8764  	              nBytes++;
  8765  	          }
  8766  	      }
  8767  	      return WordArray.create(words, nBytes);
  8768  	    }
  8769  	}());
  8770  
  8771  
  8772  	return CryptoJS.enc.Base64;
  8773  
  8774  }));
  8775  },{"./core":53}],55:[function(require,module,exports){
  8776  ;(function (root, factory) {
  8777  	if (typeof exports === "object") {
  8778  		// CommonJS
  8779  		module.exports = exports = factory(require("./core"));
  8780  	}
  8781  	else if (typeof define === "function" && define.amd) {
  8782  		// AMD
  8783  		define(["./core"], factory);
  8784  	}
  8785  	else {
  8786  		// Global (browser)
  8787  		factory(root.CryptoJS);
  8788  	}
  8789  }(this, function (CryptoJS) {
  8790  
  8791  	(function () {
  8792  	    // Shortcuts
  8793  	    var C = CryptoJS;
  8794  	    var C_lib = C.lib;
  8795  	    var WordArray = C_lib.WordArray;
  8796  	    var C_enc = C.enc;
  8797  
  8798  	    /**
  8799  	     * UTF-16 BE encoding strategy.
  8800  	     */
  8801  	    var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = {
  8802  	        /**
  8803  	         * Converts a word array to a UTF-16 BE string.
  8804  	         *
  8805  	         * @param {WordArray} wordArray The word array.
  8806  	         *
  8807  	         * @return {string} The UTF-16 BE string.
  8808  	         *
  8809  	         * @static
  8810  	         *
  8811  	         * @example
  8812  	         *
  8813  	         *     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
  8814  	         */
  8815  	        stringify: function (wordArray) {
  8816  	            // Shortcuts
  8817  	            var words = wordArray.words;
  8818  	            var sigBytes = wordArray.sigBytes;
  8819  
  8820  	            // Convert
  8821  	            var utf16Chars = [];
  8822  	            for (var i = 0; i < sigBytes; i += 2) {
  8823  	                var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
  8824  	                utf16Chars.push(String.fromCharCode(codePoint));
  8825  	            }
  8826  
  8827  	            return utf16Chars.join('');
  8828  	        },
  8829  
  8830  	        /**
  8831  	         * Converts a UTF-16 BE string to a word array.
  8832  	         *
  8833  	         * @param {string} utf16Str The UTF-16 BE string.
  8834  	         *
  8835  	         * @return {WordArray} The word array.
  8836  	         *
  8837  	         * @static
  8838  	         *
  8839  	         * @example
  8840  	         *
  8841  	         *     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
  8842  	         */
  8843  	        parse: function (utf16Str) {
  8844  	            // Shortcut
  8845  	            var utf16StrLength = utf16Str.length;
  8846  
  8847  	            // Convert
  8848  	            var words = [];
  8849  	            for (var i = 0; i < utf16StrLength; i++) {
  8850  	                words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
  8851  	            }
  8852  
  8853  	            return WordArray.create(words, utf16StrLength * 2);
  8854  	        }
  8855  	    };
  8856  
  8857  	    /**
  8858  	     * UTF-16 LE encoding strategy.
  8859  	     */
  8860  	    C_enc.Utf16LE = {
  8861  	        /**
  8862  	         * Converts a word array to a UTF-16 LE string.
  8863  	         *
  8864  	         * @param {WordArray} wordArray The word array.
  8865  	         *
  8866  	         * @return {string} The UTF-16 LE string.
  8867  	         *
  8868  	         * @static
  8869  	         *
  8870  	         * @example
  8871  	         *
  8872  	         *     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
  8873  	         */
  8874  	        stringify: function (wordArray) {
  8875  	            // Shortcuts
  8876  	            var words = wordArray.words;
  8877  	            var sigBytes = wordArray.sigBytes;
  8878  
  8879  	            // Convert
  8880  	            var utf16Chars = [];
  8881  	            for (var i = 0; i < sigBytes; i += 2) {
  8882  	                var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
  8883  	                utf16Chars.push(String.fromCharCode(codePoint));
  8884  	            }
  8885  
  8886  	            return utf16Chars.join('');
  8887  	        },
  8888  
  8889  	        /**
  8890  	         * Converts a UTF-16 LE string to a word array.
  8891  	         *
  8892  	         * @param {string} utf16Str The UTF-16 LE string.
  8893  	         *
  8894  	         * @return {WordArray} The word array.
  8895  	         *
  8896  	         * @static
  8897  	         *
  8898  	         * @example
  8899  	         *
  8900  	         *     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
  8901  	         */
  8902  	        parse: function (utf16Str) {
  8903  	            // Shortcut
  8904  	            var utf16StrLength = utf16Str.length;
  8905  
  8906  	            // Convert
  8907  	            var words = [];
  8908  	            for (var i = 0; i < utf16StrLength; i++) {
  8909  	                words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
  8910  	            }
  8911  
  8912  	            return WordArray.create(words, utf16StrLength * 2);
  8913  	        }
  8914  	    };
  8915  
  8916  	    function swapEndian(word) {
  8917  	        return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
  8918  	    }
  8919  	}());
  8920  
  8921  
  8922  	return CryptoJS.enc.Utf16;
  8923  
  8924  }));
  8925  },{"./core":53}],56:[function(require,module,exports){
  8926  ;(function (root, factory, undef) {
  8927  	if (typeof exports === "object") {
  8928  		// CommonJS
  8929  		module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
  8930  	}
  8931  	else if (typeof define === "function" && define.amd) {
  8932  		// AMD
  8933  		define(["./core", "./sha1", "./hmac"], factory);
  8934  	}
  8935  	else {
  8936  		// Global (browser)
  8937  		factory(root.CryptoJS);
  8938  	}
  8939  }(this, function (CryptoJS) {
  8940  
  8941  	(function () {
  8942  	    // Shortcuts
  8943  	    var C = CryptoJS;
  8944  	    var C_lib = C.lib;
  8945  	    var Base = C_lib.Base;
  8946  	    var WordArray = C_lib.WordArray;
  8947  	    var C_algo = C.algo;
  8948  	    var MD5 = C_algo.MD5;
  8949  
  8950  	    /**
  8951  	     * This key derivation function is meant to conform with EVP_BytesToKey.
  8952  	     * www.openssl.org/docs/crypto/EVP_BytesToKey.html
  8953  	     */
  8954  	    var EvpKDF = C_algo.EvpKDF = Base.extend({
  8955  	        /**
  8956  	         * Configuration options.
  8957  	         *
  8958  	         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
  8959  	         * @property {Hasher} hasher The hash algorithm to use. Default: MD5
  8960  	         * @property {number} iterations The number of iterations to perform. Default: 1
  8961  	         */
  8962  	        cfg: Base.extend({
  8963  	            keySize: 128/32,
  8964  	            hasher: MD5,
  8965  	            iterations: 1
  8966  	        }),
  8967  
  8968  	        /**
  8969  	         * Initializes a newly created key derivation function.
  8970  	         *
  8971  	         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
  8972  	         *
  8973  	         * @example
  8974  	         *
  8975  	         *     var kdf = CryptoJS.algo.EvpKDF.create();
  8976  	         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
  8977  	         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
  8978  	         */
  8979  	        init: function (cfg) {
  8980  	            this.cfg = this.cfg.extend(cfg);
  8981  	        },
  8982  
  8983  	        /**
  8984  	         * Derives a key from a password.
  8985  	         *
  8986  	         * @param {WordArray|string} password The password.
  8987  	         * @param {WordArray|string} salt A salt.
  8988  	         *
  8989  	         * @return {WordArray} The derived key.
  8990  	         *
  8991  	         * @example
  8992  	         *
  8993  	         *     var key = kdf.compute(password, salt);
  8994  	         */
  8995  	        compute: function (password, salt) {
  8996  	            // Shortcut
  8997  	            var cfg = this.cfg;
  8998  
  8999  	            // Init hasher
  9000  	            var hasher = cfg.hasher.create();
  9001  
  9002  	            // Initial values
  9003  	            var derivedKey = WordArray.create();
  9004  
  9005  	            // Shortcuts
  9006  	            var derivedKeyWords = derivedKey.words;
  9007  	            var keySize = cfg.keySize;
  9008  	            var iterations = cfg.iterations;
  9009  
  9010  	            // Generate key
  9011  	            while (derivedKeyWords.length < keySize) {
  9012  	                if (block) {
  9013  	                    hasher.update(block);
  9014  	                }
  9015  	                var block = hasher.update(password).finalize(salt);
  9016  	                hasher.reset();
  9017  
  9018  	                // Iterations
  9019  	                for (var i = 1; i < iterations; i++) {
  9020  	                    block = hasher.finalize(block);
  9021  	                    hasher.reset();
  9022  	                }
  9023  
  9024  	                derivedKey.concat(block);
  9025  	            }
  9026  	            derivedKey.sigBytes = keySize * 4;
  9027  
  9028  	            return derivedKey;
  9029  	        }
  9030  	    });
  9031  
  9032  	    /**
  9033  	     * Derives a key from a password.
  9034  	     *
  9035  	     * @param {WordArray|string} password The password.
  9036  	     * @param {WordArray|string} salt A salt.
  9037  	     * @param {Object} cfg (Optional) The configuration options to use for this computation.
  9038  	     *
  9039  	     * @return {WordArray} The derived key.
  9040  	     *
  9041  	     * @static
  9042  	     *
  9043  	     * @example
  9044  	     *
  9045  	     *     var key = CryptoJS.EvpKDF(password, salt);
  9046  	     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
  9047  	     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
  9048  	     */
  9049  	    C.EvpKDF = function (password, salt, cfg) {
  9050  	        return EvpKDF.create(cfg).compute(password, salt);
  9051  	    };
  9052  	}());
  9053  
  9054  
  9055  	return CryptoJS.EvpKDF;
  9056  
  9057  }));
  9058  },{"./core":53,"./hmac":58,"./sha1":77}],57:[function(require,module,exports){
  9059  ;(function (root, factory, undef) {
  9060  	if (typeof exports === "object") {
  9061  		// CommonJS
  9062  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9063  	}
  9064  	else if (typeof define === "function" && define.amd) {
  9065  		// AMD
  9066  		define(["./core", "./cipher-core"], factory);
  9067  	}
  9068  	else {
  9069  		// Global (browser)
  9070  		factory(root.CryptoJS);
  9071  	}
  9072  }(this, function (CryptoJS) {
  9073  
  9074  	(function (undefined) {
  9075  	    // Shortcuts
  9076  	    var C = CryptoJS;
  9077  	    var C_lib = C.lib;
  9078  	    var CipherParams = C_lib.CipherParams;
  9079  	    var C_enc = C.enc;
  9080  	    var Hex = C_enc.Hex;
  9081  	    var C_format = C.format;
  9082  
  9083  	    var HexFormatter = C_format.Hex = {
  9084  	        /**
  9085  	         * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
  9086  	         *
  9087  	         * @param {CipherParams} cipherParams The cipher params object.
  9088  	         *
  9089  	         * @return {string} The hexadecimally encoded string.
  9090  	         *
  9091  	         * @static
  9092  	         *
  9093  	         * @example
  9094  	         *
  9095  	         *     var hexString = CryptoJS.format.Hex.stringify(cipherParams);
  9096  	         */
  9097  	        stringify: function (cipherParams) {
  9098  	            return cipherParams.ciphertext.toString(Hex);
  9099  	        },
  9100  
  9101  	        /**
  9102  	         * Converts a hexadecimally encoded ciphertext string to a cipher params object.
  9103  	         *
  9104  	         * @param {string} input The hexadecimally encoded string.
  9105  	         *
  9106  	         * @return {CipherParams} The cipher params object.
  9107  	         *
  9108  	         * @static
  9109  	         *
  9110  	         * @example
  9111  	         *
  9112  	         *     var cipherParams = CryptoJS.format.Hex.parse(hexString);
  9113  	         */
  9114  	        parse: function (input) {
  9115  	            var ciphertext = Hex.parse(input);
  9116  	            return CipherParams.create({ ciphertext: ciphertext });
  9117  	        }
  9118  	    };
  9119  	}());
  9120  
  9121  
  9122  	return CryptoJS.format.Hex;
  9123  
  9124  }));
  9125  },{"./cipher-core":52,"./core":53}],58:[function(require,module,exports){
  9126  ;(function (root, factory) {
  9127  	if (typeof exports === "object") {
  9128  		// CommonJS
  9129  		module.exports = exports = factory(require("./core"));
  9130  	}
  9131  	else if (typeof define === "function" && define.amd) {
  9132  		// AMD
  9133  		define(["./core"], factory);
  9134  	}
  9135  	else {
  9136  		// Global (browser)
  9137  		factory(root.CryptoJS);
  9138  	}
  9139  }(this, function (CryptoJS) {
  9140  
  9141  	(function () {
  9142  	    // Shortcuts
  9143  	    var C = CryptoJS;
  9144  	    var C_lib = C.lib;
  9145  	    var Base = C_lib.Base;
  9146  	    var C_enc = C.enc;
  9147  	    var Utf8 = C_enc.Utf8;
  9148  	    var C_algo = C.algo;
  9149  
  9150  	    /**
  9151  	     * HMAC algorithm.
  9152  	     */
  9153  	    var HMAC = C_algo.HMAC = Base.extend({
  9154  	        /**
  9155  	         * Initializes a newly created HMAC.
  9156  	         *
  9157  	         * @param {Hasher} hasher The hash algorithm to use.
  9158  	         * @param {WordArray|string} key The secret key.
  9159  	         *
  9160  	         * @example
  9161  	         *
  9162  	         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
  9163  	         */
  9164  	        init: function (hasher, key) {
  9165  	            // Init hasher
  9166  	            hasher = this._hasher = new hasher.init();
  9167  
  9168  	            // Convert string to WordArray, else assume WordArray already
  9169  	            if (typeof key == 'string') {
  9170  	                key = Utf8.parse(key);
  9171  	            }
  9172  
  9173  	            // Shortcuts
  9174  	            var hasherBlockSize = hasher.blockSize;
  9175  	            var hasherBlockSizeBytes = hasherBlockSize * 4;
  9176  
  9177  	            // Allow arbitrary length keys
  9178  	            if (key.sigBytes > hasherBlockSizeBytes) {
  9179  	                key = hasher.finalize(key);
  9180  	            }
  9181  
  9182  	            // Clamp excess bits
  9183  	            key.clamp();
  9184  
  9185  	            // Clone key for inner and outer pads
  9186  	            var oKey = this._oKey = key.clone();
  9187  	            var iKey = this._iKey = key.clone();
  9188  
  9189  	            // Shortcuts
  9190  	            var oKeyWords = oKey.words;
  9191  	            var iKeyWords = iKey.words;
  9192  
  9193  	            // XOR keys with pad constants
  9194  	            for (var i = 0; i < hasherBlockSize; i++) {
  9195  	                oKeyWords[i] ^= 0x5c5c5c5c;
  9196  	                iKeyWords[i] ^= 0x36363636;
  9197  	            }
  9198  	            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
  9199  
  9200  	            // Set initial values
  9201  	            this.reset();
  9202  	        },
  9203  
  9204  	        /**
  9205  	         * Resets this HMAC to its initial state.
  9206  	         *
  9207  	         * @example
  9208  	         *
  9209  	         *     hmacHasher.reset();
  9210  	         */
  9211  	        reset: function () {
  9212  	            // Shortcut
  9213  	            var hasher = this._hasher;
  9214  
  9215  	            // Reset
  9216  	            hasher.reset();
  9217  	            hasher.update(this._iKey);
  9218  	        },
  9219  
  9220  	        /**
  9221  	         * Updates this HMAC with a message.
  9222  	         *
  9223  	         * @param {WordArray|string} messageUpdate The message to append.
  9224  	         *
  9225  	         * @return {HMAC} This HMAC instance.
  9226  	         *
  9227  	         * @example
  9228  	         *
  9229  	         *     hmacHasher.update('message');
  9230  	         *     hmacHasher.update(wordArray);
  9231  	         */
  9232  	        update: function (messageUpdate) {
  9233  	            this._hasher.update(messageUpdate);
  9234  
  9235  	            // Chainable
  9236  	            return this;
  9237  	        },
  9238  
  9239  	        /**
  9240  	         * Finalizes the HMAC computation.
  9241  	         * Note that the finalize operation is effectively a destructive, read-once operation.
  9242  	         *
  9243  	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
  9244  	         *
  9245  	         * @return {WordArray} The HMAC.
  9246  	         *
  9247  	         * @example
  9248  	         *
  9249  	         *     var hmac = hmacHasher.finalize();
  9250  	         *     var hmac = hmacHasher.finalize('message');
  9251  	         *     var hmac = hmacHasher.finalize(wordArray);
  9252  	         */
  9253  	        finalize: function (messageUpdate) {
  9254  	            // Shortcut
  9255  	            var hasher = this._hasher;
  9256  
  9257  	            // Compute HMAC
  9258  	            var innerHash = hasher.finalize(messageUpdate);
  9259  	            hasher.reset();
  9260  	            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
  9261  
  9262  	            return hmac;
  9263  	        }
  9264  	    });
  9265  	}());
  9266  
  9267  
  9268  }));
  9269  },{"./core":53}],59:[function(require,module,exports){
  9270  ;(function (root, factory, undef) {
  9271  	if (typeof exports === "object") {
  9272  		// CommonJS
  9273  		module.exports = exports = factory(require("./core"), require("./x64-core"), require("./lib-typedarrays"), require("./enc-utf16"), require("./enc-base64"), require("./md5"), require("./sha1"), require("./sha256"), require("./sha224"), require("./sha512"), require("./sha384"), require("./sha3"), require("./ripemd160"), require("./hmac"), require("./pbkdf2"), require("./evpkdf"), require("./cipher-core"), require("./mode-cfb"), require("./mode-ctr"), require("./mode-ctr-gladman"), require("./mode-ofb"), require("./mode-ecb"), require("./pad-ansix923"), require("./pad-iso10126"), require("./pad-iso97971"), require("./pad-zeropadding"), require("./pad-nopadding"), require("./format-hex"), require("./aes"), require("./tripledes"), require("./rc4"), require("./rabbit"), require("./rabbit-legacy"));
  9274  	}
  9275  	else if (typeof define === "function" && define.amd) {
  9276  		// AMD
  9277  		define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy"], factory);
  9278  	}
  9279  	else {
  9280  		// Global (browser)
  9281  		root.CryptoJS = factory(root.CryptoJS);
  9282  	}
  9283  }(this, function (CryptoJS) {
  9284  
  9285  	return CryptoJS;
  9286  
  9287  }));
  9288  },{"./aes":51,"./cipher-core":52,"./core":53,"./enc-base64":54,"./enc-utf16":55,"./evpkdf":56,"./format-hex":57,"./hmac":58,"./lib-typedarrays":60,"./md5":61,"./mode-cfb":62,"./mode-ctr":64,"./mode-ctr-gladman":63,"./mode-ecb":65,"./mode-ofb":66,"./pad-ansix923":67,"./pad-iso10126":68,"./pad-iso97971":69,"./pad-nopadding":70,"./pad-zeropadding":71,"./pbkdf2":72,"./rabbit":74,"./rabbit-legacy":73,"./rc4":75,"./ripemd160":76,"./sha1":77,"./sha224":78,"./sha256":79,"./sha3":80,"./sha384":81,"./sha512":82,"./tripledes":83,"./x64-core":84}],60:[function(require,module,exports){
  9289  ;(function (root, factory) {
  9290  	if (typeof exports === "object") {
  9291  		// CommonJS
  9292  		module.exports = exports = factory(require("./core"));
  9293  	}
  9294  	else if (typeof define === "function" && define.amd) {
  9295  		// AMD
  9296  		define(["./core"], factory);
  9297  	}
  9298  	else {
  9299  		// Global (browser)
  9300  		factory(root.CryptoJS);
  9301  	}
  9302  }(this, function (CryptoJS) {
  9303  
  9304  	(function () {
  9305  	    // Check if typed arrays are supported
  9306  	    if (typeof ArrayBuffer != 'function') {
  9307  	        return;
  9308  	    }
  9309  
  9310  	    // Shortcuts
  9311  	    var C = CryptoJS;
  9312  	    var C_lib = C.lib;
  9313  	    var WordArray = C_lib.WordArray;
  9314  
  9315  	    // Reference original init
  9316  	    var superInit = WordArray.init;
  9317  
  9318  	    // Augment WordArray.init to handle typed arrays
  9319  	    var subInit = WordArray.init = function (typedArray) {
  9320  	        // Convert buffers to uint8
  9321  	        if (typedArray instanceof ArrayBuffer) {
  9322  	            typedArray = new Uint8Array(typedArray);
  9323  	        }
  9324  
  9325  	        // Convert other array views to uint8
  9326  	        if (
  9327  	            typedArray instanceof Int8Array ||
  9328  	            (typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) ||
  9329  	            typedArray instanceof Int16Array ||
  9330  	            typedArray instanceof Uint16Array ||
  9331  	            typedArray instanceof Int32Array ||
  9332  	            typedArray instanceof Uint32Array ||
  9333  	            typedArray instanceof Float32Array ||
  9334  	            typedArray instanceof Float64Array
  9335  	        ) {
  9336  	            typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
  9337  	        }
  9338  
  9339  	        // Handle Uint8Array
  9340  	        if (typedArray instanceof Uint8Array) {
  9341  	            // Shortcut
  9342  	            var typedArrayByteLength = typedArray.byteLength;
  9343  
  9344  	            // Extract bytes
  9345  	            var words = [];
  9346  	            for (var i = 0; i < typedArrayByteLength; i++) {
  9347  	                words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);
  9348  	            }
  9349  
  9350  	            // Initialize this word array
  9351  	            superInit.call(this, words, typedArrayByteLength);
  9352  	        } else {
  9353  	            // Else call normal init
  9354  	            superInit.apply(this, arguments);
  9355  	        }
  9356  	    };
  9357  
  9358  	    subInit.prototype = WordArray;
  9359  	}());
  9360  
  9361  
  9362  	return CryptoJS.lib.WordArray;
  9363  
  9364  }));
  9365  },{"./core":53}],61:[function(require,module,exports){
  9366  ;(function (root, factory) {
  9367  	if (typeof exports === "object") {
  9368  		// CommonJS
  9369  		module.exports = exports = factory(require("./core"));
  9370  	}
  9371  	else if (typeof define === "function" && define.amd) {
  9372  		// AMD
  9373  		define(["./core"], factory);
  9374  	}
  9375  	else {
  9376  		// Global (browser)
  9377  		factory(root.CryptoJS);
  9378  	}
  9379  }(this, function (CryptoJS) {
  9380  
  9381  	(function (Math) {
  9382  	    // Shortcuts
  9383  	    var C = CryptoJS;
  9384  	    var C_lib = C.lib;
  9385  	    var WordArray = C_lib.WordArray;
  9386  	    var Hasher = C_lib.Hasher;
  9387  	    var C_algo = C.algo;
  9388  
  9389  	    // Constants table
  9390  	    var T = [];
  9391  
  9392  	    // Compute constants
  9393  	    (function () {
  9394  	        for (var i = 0; i < 64; i++) {
  9395  	            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
  9396  	        }
  9397  	    }());
  9398  
  9399  	    /**
  9400  	     * MD5 hash algorithm.
  9401  	     */
  9402  	    var MD5 = C_algo.MD5 = Hasher.extend({
  9403  	        _doReset: function () {
  9404  	            this._hash = new WordArray.init([
  9405  	                0x67452301, 0xefcdab89,
  9406  	                0x98badcfe, 0x10325476
  9407  	            ]);
  9408  	        },
  9409  
  9410  	        _doProcessBlock: function (M, offset) {
  9411  	            // Swap endian
  9412  	            for (var i = 0; i < 16; i++) {
  9413  	                // Shortcuts
  9414  	                var offset_i = offset + i;
  9415  	                var M_offset_i = M[offset_i];
  9416  
  9417  	                M[offset_i] = (
  9418  	                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
  9419  	                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
  9420  	                );
  9421  	            }
  9422  
  9423  	            // Shortcuts
  9424  	            var H = this._hash.words;
  9425  
  9426  	            var M_offset_0  = M[offset + 0];
  9427  	            var M_offset_1  = M[offset + 1];
  9428  	            var M_offset_2  = M[offset + 2];
  9429  	            var M_offset_3  = M[offset + 3];
  9430  	            var M_offset_4  = M[offset + 4];
  9431  	            var M_offset_5  = M[offset + 5];
  9432  	            var M_offset_6  = M[offset + 6];
  9433  	            var M_offset_7  = M[offset + 7];
  9434  	            var M_offset_8  = M[offset + 8];
  9435  	            var M_offset_9  = M[offset + 9];
  9436  	            var M_offset_10 = M[offset + 10];
  9437  	            var M_offset_11 = M[offset + 11];
  9438  	            var M_offset_12 = M[offset + 12];
  9439  	            var M_offset_13 = M[offset + 13];
  9440  	            var M_offset_14 = M[offset + 14];
  9441  	            var M_offset_15 = M[offset + 15];
  9442  
  9443  	            // Working varialbes
  9444  	            var a = H[0];
  9445  	            var b = H[1];
  9446  	            var c = H[2];
  9447  	            var d = H[3];
  9448  
  9449  	            // Computation
  9450  	            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);
  9451  	            d = FF(d, a, b, c, M_offset_1,  12, T[1]);
  9452  	            c = FF(c, d, a, b, M_offset_2,  17, T[2]);
  9453  	            b = FF(b, c, d, a, M_offset_3,  22, T[3]);
  9454  	            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);
  9455  	            d = FF(d, a, b, c, M_offset_5,  12, T[5]);
  9456  	            c = FF(c, d, a, b, M_offset_6,  17, T[6]);
  9457  	            b = FF(b, c, d, a, M_offset_7,  22, T[7]);
  9458  	            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);
  9459  	            d = FF(d, a, b, c, M_offset_9,  12, T[9]);
  9460  	            c = FF(c, d, a, b, M_offset_10, 17, T[10]);
  9461  	            b = FF(b, c, d, a, M_offset_11, 22, T[11]);
  9462  	            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);
  9463  	            d = FF(d, a, b, c, M_offset_13, 12, T[13]);
  9464  	            c = FF(c, d, a, b, M_offset_14, 17, T[14]);
  9465  	            b = FF(b, c, d, a, M_offset_15, 22, T[15]);
  9466  
  9467  	            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);
  9468  	            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);
  9469  	            c = GG(c, d, a, b, M_offset_11, 14, T[18]);
  9470  	            b = GG(b, c, d, a, M_offset_0,  20, T[19]);
  9471  	            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);
  9472  	            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);
  9473  	            c = GG(c, d, a, b, M_offset_15, 14, T[22]);
  9474  	            b = GG(b, c, d, a, M_offset_4,  20, T[23]);
  9475  	            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);
  9476  	            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);
  9477  	            c = GG(c, d, a, b, M_offset_3,  14, T[26]);
  9478  	            b = GG(b, c, d, a, M_offset_8,  20, T[27]);
  9479  	            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);
  9480  	            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);
  9481  	            c = GG(c, d, a, b, M_offset_7,  14, T[30]);
  9482  	            b = GG(b, c, d, a, M_offset_12, 20, T[31]);
  9483  
  9484  	            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);
  9485  	            d = HH(d, a, b, c, M_offset_8,  11, T[33]);
  9486  	            c = HH(c, d, a, b, M_offset_11, 16, T[34]);
  9487  	            b = HH(b, c, d, a, M_offset_14, 23, T[35]);
  9488  	            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);
  9489  	            d = HH(d, a, b, c, M_offset_4,  11, T[37]);
  9490  	            c = HH(c, d, a, b, M_offset_7,  16, T[38]);
  9491  	            b = HH(b, c, d, a, M_offset_10, 23, T[39]);
  9492  	            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);
  9493  	            d = HH(d, a, b, c, M_offset_0,  11, T[41]);
  9494  	            c = HH(c, d, a, b, M_offset_3,  16, T[42]);
  9495  	            b = HH(b, c, d, a, M_offset_6,  23, T[43]);
  9496  	            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);
  9497  	            d = HH(d, a, b, c, M_offset_12, 11, T[45]);
  9498  	            c = HH(c, d, a, b, M_offset_15, 16, T[46]);
  9499  	            b = HH(b, c, d, a, M_offset_2,  23, T[47]);
  9500  
  9501  	            a = II(a, b, c, d, M_offset_0,  6,  T[48]);
  9502  	            d = II(d, a, b, c, M_offset_7,  10, T[49]);
  9503  	            c = II(c, d, a, b, M_offset_14, 15, T[50]);
  9504  	            b = II(b, c, d, a, M_offset_5,  21, T[51]);
  9505  	            a = II(a, b, c, d, M_offset_12, 6,  T[52]);
  9506  	            d = II(d, a, b, c, M_offset_3,  10, T[53]);
  9507  	            c = II(c, d, a, b, M_offset_10, 15, T[54]);
  9508  	            b = II(b, c, d, a, M_offset_1,  21, T[55]);
  9509  	            a = II(a, b, c, d, M_offset_8,  6,  T[56]);
  9510  	            d = II(d, a, b, c, M_offset_15, 10, T[57]);
  9511  	            c = II(c, d, a, b, M_offset_6,  15, T[58]);
  9512  	            b = II(b, c, d, a, M_offset_13, 21, T[59]);
  9513  	            a = II(a, b, c, d, M_offset_4,  6,  T[60]);
  9514  	            d = II(d, a, b, c, M_offset_11, 10, T[61]);
  9515  	            c = II(c, d, a, b, M_offset_2,  15, T[62]);
  9516  	            b = II(b, c, d, a, M_offset_9,  21, T[63]);
  9517  
  9518  	            // Intermediate hash value
  9519  	            H[0] = (H[0] + a) | 0;
  9520  	            H[1] = (H[1] + b) | 0;
  9521  	            H[2] = (H[2] + c) | 0;
  9522  	            H[3] = (H[3] + d) | 0;
  9523  	        },
  9524  
  9525  	        _doFinalize: function () {
  9526  	            // Shortcuts
  9527  	            var data = this._data;
  9528  	            var dataWords = data.words;
  9529  
  9530  	            var nBitsTotal = this._nDataBytes * 8;
  9531  	            var nBitsLeft = data.sigBytes * 8;
  9532  
  9533  	            // Add padding
  9534  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
  9535  
  9536  	            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
  9537  	            var nBitsTotalL = nBitsTotal;
  9538  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
  9539  	                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
  9540  	                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
  9541  	            );
  9542  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
  9543  	                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
  9544  	                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
  9545  	            );
  9546  
  9547  	            data.sigBytes = (dataWords.length + 1) * 4;
  9548  
  9549  	            // Hash final blocks
  9550  	            this._process();
  9551  
  9552  	            // Shortcuts
  9553  	            var hash = this._hash;
  9554  	            var H = hash.words;
  9555  
  9556  	            // Swap endian
  9557  	            for (var i = 0; i < 4; i++) {
  9558  	                // Shortcut
  9559  	                var H_i = H[i];
  9560  
  9561  	                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
  9562  	                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
  9563  	            }
  9564  
  9565  	            // Return final computed hash
  9566  	            return hash;
  9567  	        },
  9568  
  9569  	        clone: function () {
  9570  	            var clone = Hasher.clone.call(this);
  9571  	            clone._hash = this._hash.clone();
  9572  
  9573  	            return clone;
  9574  	        }
  9575  	    });
  9576  
  9577  	    function FF(a, b, c, d, x, s, t) {
  9578  	        var n = a + ((b & c) | (~b & d)) + x + t;
  9579  	        return ((n << s) | (n >>> (32 - s))) + b;
  9580  	    }
  9581  
  9582  	    function GG(a, b, c, d, x, s, t) {
  9583  	        var n = a + ((b & d) | (c & ~d)) + x + t;
  9584  	        return ((n << s) | (n >>> (32 - s))) + b;
  9585  	    }
  9586  
  9587  	    function HH(a, b, c, d, x, s, t) {
  9588  	        var n = a + (b ^ c ^ d) + x + t;
  9589  	        return ((n << s) | (n >>> (32 - s))) + b;
  9590  	    }
  9591  
  9592  	    function II(a, b, c, d, x, s, t) {
  9593  	        var n = a + (c ^ (b | ~d)) + x + t;
  9594  	        return ((n << s) | (n >>> (32 - s))) + b;
  9595  	    }
  9596  
  9597  	    /**
  9598  	     * Shortcut function to the hasher's object interface.
  9599  	     *
  9600  	     * @param {WordArray|string} message The message to hash.
  9601  	     *
  9602  	     * @return {WordArray} The hash.
  9603  	     *
  9604  	     * @static
  9605  	     *
  9606  	     * @example
  9607  	     *
  9608  	     *     var hash = CryptoJS.MD5('message');
  9609  	     *     var hash = CryptoJS.MD5(wordArray);
  9610  	     */
  9611  	    C.MD5 = Hasher._createHelper(MD5);
  9612  
  9613  	    /**
  9614  	     * Shortcut function to the HMAC's object interface.
  9615  	     *
  9616  	     * @param {WordArray|string} message The message to hash.
  9617  	     * @param {WordArray|string} key The secret key.
  9618  	     *
  9619  	     * @return {WordArray} The HMAC.
  9620  	     *
  9621  	     * @static
  9622  	     *
  9623  	     * @example
  9624  	     *
  9625  	     *     var hmac = CryptoJS.HmacMD5(message, key);
  9626  	     */
  9627  	    C.HmacMD5 = Hasher._createHmacHelper(MD5);
  9628  	}(Math));
  9629  
  9630  
  9631  	return CryptoJS.MD5;
  9632  
  9633  }));
  9634  },{"./core":53}],62:[function(require,module,exports){
  9635  ;(function (root, factory, undef) {
  9636  	if (typeof exports === "object") {
  9637  		// CommonJS
  9638  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9639  	}
  9640  	else if (typeof define === "function" && define.amd) {
  9641  		// AMD
  9642  		define(["./core", "./cipher-core"], factory);
  9643  	}
  9644  	else {
  9645  		// Global (browser)
  9646  		factory(root.CryptoJS);
  9647  	}
  9648  }(this, function (CryptoJS) {
  9649  
  9650  	/**
  9651  	 * Cipher Feedback block mode.
  9652  	 */
  9653  	CryptoJS.mode.CFB = (function () {
  9654  	    var CFB = CryptoJS.lib.BlockCipherMode.extend();
  9655  
  9656  	    CFB.Encryptor = CFB.extend({
  9657  	        processBlock: function (words, offset) {
  9658  	            // Shortcuts
  9659  	            var cipher = this._cipher;
  9660  	            var blockSize = cipher.blockSize;
  9661  
  9662  	            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
  9663  
  9664  	            // Remember this block to use with next block
  9665  	            this._prevBlock = words.slice(offset, offset + blockSize);
  9666  	        }
  9667  	    });
  9668  
  9669  	    CFB.Decryptor = CFB.extend({
  9670  	        processBlock: function (words, offset) {
  9671  	            // Shortcuts
  9672  	            var cipher = this._cipher;
  9673  	            var blockSize = cipher.blockSize;
  9674  
  9675  	            // Remember this block to use with next block
  9676  	            var thisBlock = words.slice(offset, offset + blockSize);
  9677  
  9678  	            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
  9679  
  9680  	            // This block becomes the previous block
  9681  	            this._prevBlock = thisBlock;
  9682  	        }
  9683  	    });
  9684  
  9685  	    function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
  9686  	        // Shortcut
  9687  	        var iv = this._iv;
  9688  
  9689  	        // Generate keystream
  9690  	        if (iv) {
  9691  	            var keystream = iv.slice(0);
  9692  
  9693  	            // Remove IV for subsequent blocks
  9694  	            this._iv = undefined;
  9695  	        } else {
  9696  	            var keystream = this._prevBlock;
  9697  	        }
  9698  	        cipher.encryptBlock(keystream, 0);
  9699  
  9700  	        // Encrypt
  9701  	        for (var i = 0; i < blockSize; i++) {
  9702  	            words[offset + i] ^= keystream[i];
  9703  	        }
  9704  	    }
  9705  
  9706  	    return CFB;
  9707  	}());
  9708  
  9709  
  9710  	return CryptoJS.mode.CFB;
  9711  
  9712  }));
  9713  },{"./cipher-core":52,"./core":53}],63:[function(require,module,exports){
  9714  ;(function (root, factory, undef) {
  9715  	if (typeof exports === "object") {
  9716  		// CommonJS
  9717  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9718  	}
  9719  	else if (typeof define === "function" && define.amd) {
  9720  		// AMD
  9721  		define(["./core", "./cipher-core"], factory);
  9722  	}
  9723  	else {
  9724  		// Global (browser)
  9725  		factory(root.CryptoJS);
  9726  	}
  9727  }(this, function (CryptoJS) {
  9728  
  9729  	/** @preserve
  9730  	 * Counter block mode compatible with  Dr Brian Gladman fileenc.c
  9731  	 * derived from CryptoJS.mode.CTR
  9732  	 * Jan Hruby jhruby.web@gmail.com
  9733  	 */
  9734  	CryptoJS.mode.CTRGladman = (function () {
  9735  	    var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
  9736  
  9737  		function incWord(word)
  9738  		{
  9739  			if (((word >> 24) & 0xff) === 0xff) { //overflow
  9740  			var b1 = (word >> 16)&0xff;
  9741  			var b2 = (word >> 8)&0xff;
  9742  			var b3 = word & 0xff;
  9743  
  9744  			if (b1 === 0xff) // overflow b1
  9745  			{
  9746  			b1 = 0;
  9747  			if (b2 === 0xff)
  9748  			{
  9749  				b2 = 0;
  9750  				if (b3 === 0xff)
  9751  				{
  9752  					b3 = 0;
  9753  				}
  9754  				else
  9755  				{
  9756  					++b3;
  9757  				}
  9758  			}
  9759  			else
  9760  			{
  9761  				++b2;
  9762  			}
  9763  			}
  9764  			else
  9765  			{
  9766  			++b1;
  9767  			}
  9768  
  9769  			word = 0;
  9770  			word += (b1 << 16);
  9771  			word += (b2 << 8);
  9772  			word += b3;
  9773  			}
  9774  			else
  9775  			{
  9776  			word += (0x01 << 24);
  9777  			}
  9778  			return word;
  9779  		}
  9780  
  9781  		function incCounter(counter)
  9782  		{
  9783  			if ((counter[0] = incWord(counter[0])) === 0)
  9784  			{
  9785  				// encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8
  9786  				counter[1] = incWord(counter[1]);
  9787  			}
  9788  			return counter;
  9789  		}
  9790  
  9791  	    var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
  9792  	        processBlock: function (words, offset) {
  9793  	            // Shortcuts
  9794  	            var cipher = this._cipher
  9795  	            var blockSize = cipher.blockSize;
  9796  	            var iv = this._iv;
  9797  	            var counter = this._counter;
  9798  
  9799  	            // Generate keystream
  9800  	            if (iv) {
  9801  	                counter = this._counter = iv.slice(0);
  9802  
  9803  	                // Remove IV for subsequent blocks
  9804  	                this._iv = undefined;
  9805  	            }
  9806  
  9807  				incCounter(counter);
  9808  
  9809  				var keystream = counter.slice(0);
  9810  	            cipher.encryptBlock(keystream, 0);
  9811  
  9812  	            // Encrypt
  9813  	            for (var i = 0; i < blockSize; i++) {
  9814  	                words[offset + i] ^= keystream[i];
  9815  	            }
  9816  	        }
  9817  	    });
  9818  
  9819  	    CTRGladman.Decryptor = Encryptor;
  9820  
  9821  	    return CTRGladman;
  9822  	}());
  9823  
  9824  
  9825  
  9826  
  9827  	return CryptoJS.mode.CTRGladman;
  9828  
  9829  }));
  9830  },{"./cipher-core":52,"./core":53}],64:[function(require,module,exports){
  9831  ;(function (root, factory, undef) {
  9832  	if (typeof exports === "object") {
  9833  		// CommonJS
  9834  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9835  	}
  9836  	else if (typeof define === "function" && define.amd) {
  9837  		// AMD
  9838  		define(["./core", "./cipher-core"], factory);
  9839  	}
  9840  	else {
  9841  		// Global (browser)
  9842  		factory(root.CryptoJS);
  9843  	}
  9844  }(this, function (CryptoJS) {
  9845  
  9846  	/**
  9847  	 * Counter block mode.
  9848  	 */
  9849  	CryptoJS.mode.CTR = (function () {
  9850  	    var CTR = CryptoJS.lib.BlockCipherMode.extend();
  9851  
  9852  	    var Encryptor = CTR.Encryptor = CTR.extend({
  9853  	        processBlock: function (words, offset) {
  9854  	            // Shortcuts
  9855  	            var cipher = this._cipher
  9856  	            var blockSize = cipher.blockSize;
  9857  	            var iv = this._iv;
  9858  	            var counter = this._counter;
  9859  
  9860  	            // Generate keystream
  9861  	            if (iv) {
  9862  	                counter = this._counter = iv.slice(0);
  9863  
  9864  	                // Remove IV for subsequent blocks
  9865  	                this._iv = undefined;
  9866  	            }
  9867  	            var keystream = counter.slice(0);
  9868  	            cipher.encryptBlock(keystream, 0);
  9869  
  9870  	            // Increment counter
  9871  	            counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0
  9872  
  9873  	            // Encrypt
  9874  	            for (var i = 0; i < blockSize; i++) {
  9875  	                words[offset + i] ^= keystream[i];
  9876  	            }
  9877  	        }
  9878  	    });
  9879  
  9880  	    CTR.Decryptor = Encryptor;
  9881  
  9882  	    return CTR;
  9883  	}());
  9884  
  9885  
  9886  	return CryptoJS.mode.CTR;
  9887  
  9888  }));
  9889  },{"./cipher-core":52,"./core":53}],65:[function(require,module,exports){
  9890  ;(function (root, factory, undef) {
  9891  	if (typeof exports === "object") {
  9892  		// CommonJS
  9893  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9894  	}
  9895  	else if (typeof define === "function" && define.amd) {
  9896  		// AMD
  9897  		define(["./core", "./cipher-core"], factory);
  9898  	}
  9899  	else {
  9900  		// Global (browser)
  9901  		factory(root.CryptoJS);
  9902  	}
  9903  }(this, function (CryptoJS) {
  9904  
  9905  	/**
  9906  	 * Electronic Codebook block mode.
  9907  	 */
  9908  	CryptoJS.mode.ECB = (function () {
  9909  	    var ECB = CryptoJS.lib.BlockCipherMode.extend();
  9910  
  9911  	    ECB.Encryptor = ECB.extend({
  9912  	        processBlock: function (words, offset) {
  9913  	            this._cipher.encryptBlock(words, offset);
  9914  	        }
  9915  	    });
  9916  
  9917  	    ECB.Decryptor = ECB.extend({
  9918  	        processBlock: function (words, offset) {
  9919  	            this._cipher.decryptBlock(words, offset);
  9920  	        }
  9921  	    });
  9922  
  9923  	    return ECB;
  9924  	}());
  9925  
  9926  
  9927  	return CryptoJS.mode.ECB;
  9928  
  9929  }));
  9930  },{"./cipher-core":52,"./core":53}],66:[function(require,module,exports){
  9931  ;(function (root, factory, undef) {
  9932  	if (typeof exports === "object") {
  9933  		// CommonJS
  9934  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9935  	}
  9936  	else if (typeof define === "function" && define.amd) {
  9937  		// AMD
  9938  		define(["./core", "./cipher-core"], factory);
  9939  	}
  9940  	else {
  9941  		// Global (browser)
  9942  		factory(root.CryptoJS);
  9943  	}
  9944  }(this, function (CryptoJS) {
  9945  
  9946  	/**
  9947  	 * Output Feedback block mode.
  9948  	 */
  9949  	CryptoJS.mode.OFB = (function () {
  9950  	    var OFB = CryptoJS.lib.BlockCipherMode.extend();
  9951  
  9952  	    var Encryptor = OFB.Encryptor = OFB.extend({
  9953  	        processBlock: function (words, offset) {
  9954  	            // Shortcuts
  9955  	            var cipher = this._cipher
  9956  	            var blockSize = cipher.blockSize;
  9957  	            var iv = this._iv;
  9958  	            var keystream = this._keystream;
  9959  
  9960  	            // Generate keystream
  9961  	            if (iv) {
  9962  	                keystream = this._keystream = iv.slice(0);
  9963  
  9964  	                // Remove IV for subsequent blocks
  9965  	                this._iv = undefined;
  9966  	            }
  9967  	            cipher.encryptBlock(keystream, 0);
  9968  
  9969  	            // Encrypt
  9970  	            for (var i = 0; i < blockSize; i++) {
  9971  	                words[offset + i] ^= keystream[i];
  9972  	            }
  9973  	        }
  9974  	    });
  9975  
  9976  	    OFB.Decryptor = Encryptor;
  9977  
  9978  	    return OFB;
  9979  	}());
  9980  
  9981  
  9982  	return CryptoJS.mode.OFB;
  9983  
  9984  }));
  9985  },{"./cipher-core":52,"./core":53}],67:[function(require,module,exports){
  9986  ;(function (root, factory, undef) {
  9987  	if (typeof exports === "object") {
  9988  		// CommonJS
  9989  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  9990  	}
  9991  	else if (typeof define === "function" && define.amd) {
  9992  		// AMD
  9993  		define(["./core", "./cipher-core"], factory);
  9994  	}
  9995  	else {
  9996  		// Global (browser)
  9997  		factory(root.CryptoJS);
  9998  	}
  9999  }(this, function (CryptoJS) {
 10000  
 10001  	/**
 10002  	 * ANSI X.923 padding strategy.
 10003  	 */
 10004  	CryptoJS.pad.AnsiX923 = {
 10005  	    pad: function (data, blockSize) {
 10006  	        // Shortcuts
 10007  	        var dataSigBytes = data.sigBytes;
 10008  	        var blockSizeBytes = blockSize * 4;
 10009  
 10010  	        // Count padding bytes
 10011  	        var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
 10012  
 10013  	        // Compute last byte position
 10014  	        var lastBytePos = dataSigBytes + nPaddingBytes - 1;
 10015  
 10016  	        // Pad
 10017  	        data.clamp();
 10018  	        data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
 10019  	        data.sigBytes += nPaddingBytes;
 10020  	    },
 10021  
 10022  	    unpad: function (data) {
 10023  	        // Get number of padding bytes from last byte
 10024  	        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
 10025  
 10026  	        // Remove padding
 10027  	        data.sigBytes -= nPaddingBytes;
 10028  	    }
 10029  	};
 10030  
 10031  
 10032  	return CryptoJS.pad.Ansix923;
 10033  
 10034  }));
 10035  },{"./cipher-core":52,"./core":53}],68:[function(require,module,exports){
 10036  ;(function (root, factory, undef) {
 10037  	if (typeof exports === "object") {
 10038  		// CommonJS
 10039  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
 10040  	}
 10041  	else if (typeof define === "function" && define.amd) {
 10042  		// AMD
 10043  		define(["./core", "./cipher-core"], factory);
 10044  	}
 10045  	else {
 10046  		// Global (browser)
 10047  		factory(root.CryptoJS);
 10048  	}
 10049  }(this, function (CryptoJS) {
 10050  
 10051  	/**
 10052  	 * ISO 10126 padding strategy.
 10053  	 */
 10054  	CryptoJS.pad.Iso10126 = {
 10055  	    pad: function (data, blockSize) {
 10056  	        // Shortcut
 10057  	        var blockSizeBytes = blockSize * 4;
 10058  
 10059  	        // Count padding bytes
 10060  	        var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
 10061  
 10062  	        // Pad
 10063  	        data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
 10064  	             concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
 10065  	    },
 10066  
 10067  	    unpad: function (data) {
 10068  	        // Get number of padding bytes from last byte
 10069  	        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
 10070  
 10071  	        // Remove padding
 10072  	        data.sigBytes -= nPaddingBytes;
 10073  	    }
 10074  	};
 10075  
 10076  
 10077  	return CryptoJS.pad.Iso10126;
 10078  
 10079  }));
 10080  },{"./cipher-core":52,"./core":53}],69:[function(require,module,exports){
 10081  ;(function (root, factory, undef) {
 10082  	if (typeof exports === "object") {
 10083  		// CommonJS
 10084  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
 10085  	}
 10086  	else if (typeof define === "function" && define.amd) {
 10087  		// AMD
 10088  		define(["./core", "./cipher-core"], factory);
 10089  	}
 10090  	else {
 10091  		// Global (browser)
 10092  		factory(root.CryptoJS);
 10093  	}
 10094  }(this, function (CryptoJS) {
 10095  
 10096  	/**
 10097  	 * ISO/IEC 9797-1 Padding Method 2.
 10098  	 */
 10099  	CryptoJS.pad.Iso97971 = {
 10100  	    pad: function (data, blockSize) {
 10101  	        // Add 0x80 byte
 10102  	        data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
 10103  
 10104  	        // Zero pad the rest
 10105  	        CryptoJS.pad.ZeroPadding.pad(data, blockSize);
 10106  	    },
 10107  
 10108  	    unpad: function (data) {
 10109  	        // Remove zero padding
 10110  	        CryptoJS.pad.ZeroPadding.unpad(data);
 10111  
 10112  	        // Remove one more byte -- the 0x80 byte
 10113  	        data.sigBytes--;
 10114  	    }
 10115  	};
 10116  
 10117  
 10118  	return CryptoJS.pad.Iso97971;
 10119  
 10120  }));
 10121  },{"./cipher-core":52,"./core":53}],70:[function(require,module,exports){
 10122  ;(function (root, factory, undef) {
 10123  	if (typeof exports === "object") {
 10124  		// CommonJS
 10125  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
 10126  	}
 10127  	else if (typeof define === "function" && define.amd) {
 10128  		// AMD
 10129  		define(["./core", "./cipher-core"], factory);
 10130  	}
 10131  	else {
 10132  		// Global (browser)
 10133  		factory(root.CryptoJS);
 10134  	}
 10135  }(this, function (CryptoJS) {
 10136  
 10137  	/**
 10138  	 * A noop padding strategy.
 10139  	 */
 10140  	CryptoJS.pad.NoPadding = {
 10141  	    pad: function () {
 10142  	    },
 10143  
 10144  	    unpad: function () {
 10145  	    }
 10146  	};
 10147  
 10148  
 10149  	return CryptoJS.pad.NoPadding;
 10150  
 10151  }));
 10152  },{"./cipher-core":52,"./core":53}],71:[function(require,module,exports){
 10153  ;(function (root, factory, undef) {
 10154  	if (typeof exports === "object") {
 10155  		// CommonJS
 10156  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
 10157  	}
 10158  	else if (typeof define === "function" && define.amd) {
 10159  		// AMD
 10160  		define(["./core", "./cipher-core"], factory);
 10161  	}
 10162  	else {
 10163  		// Global (browser)
 10164  		factory(root.CryptoJS);
 10165  	}
 10166  }(this, function (CryptoJS) {
 10167  
 10168  	/**
 10169  	 * Zero padding strategy.
 10170  	 */
 10171  	CryptoJS.pad.ZeroPadding = {
 10172  	    pad: function (data, blockSize) {
 10173  	        // Shortcut
 10174  	        var blockSizeBytes = blockSize * 4;
 10175  
 10176  	        // Pad
 10177  	        data.clamp();
 10178  	        data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
 10179  	    },
 10180  
 10181  	    unpad: function (data) {
 10182  	        // Shortcut
 10183  	        var dataWords = data.words;
 10184  
 10185  	        // Unpad
 10186  	        var i = data.sigBytes - 1;
 10187  	        while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
 10188  	            i--;
 10189  	        }
 10190  	        data.sigBytes = i + 1;
 10191  	    }
 10192  	};
 10193  
 10194  
 10195  	return CryptoJS.pad.ZeroPadding;
 10196  
 10197  }));
 10198  },{"./cipher-core":52,"./core":53}],72:[function(require,module,exports){
 10199  ;(function (root, factory, undef) {
 10200  	if (typeof exports === "object") {
 10201  		// CommonJS
 10202  		module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
 10203  	}
 10204  	else if (typeof define === "function" && define.amd) {
 10205  		// AMD
 10206  		define(["./core", "./sha1", "./hmac"], factory);
 10207  	}
 10208  	else {
 10209  		// Global (browser)
 10210  		factory(root.CryptoJS);
 10211  	}
 10212  }(this, function (CryptoJS) {
 10213  
 10214  	(function () {
 10215  	    // Shortcuts
 10216  	    var C = CryptoJS;
 10217  	    var C_lib = C.lib;
 10218  	    var Base = C_lib.Base;
 10219  	    var WordArray = C_lib.WordArray;
 10220  	    var C_algo = C.algo;
 10221  	    var SHA1 = C_algo.SHA1;
 10222  	    var HMAC = C_algo.HMAC;
 10223  
 10224  	    /**
 10225  	     * Password-Based Key Derivation Function 2 algorithm.
 10226  	     */
 10227  	    var PBKDF2 = C_algo.PBKDF2 = Base.extend({
 10228  	        /**
 10229  	         * Configuration options.
 10230  	         *
 10231  	         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
 10232  	         * @property {Hasher} hasher The hasher to use. Default: SHA1
 10233  	         * @property {number} iterations The number of iterations to perform. Default: 1
 10234  	         */
 10235  	        cfg: Base.extend({
 10236  	            keySize: 128/32,
 10237  	            hasher: SHA1,
 10238  	            iterations: 1
 10239  	        }),
 10240  
 10241  	        /**
 10242  	         * Initializes a newly created key derivation function.
 10243  	         *
 10244  	         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
 10245  	         *
 10246  	         * @example
 10247  	         *
 10248  	         *     var kdf = CryptoJS.algo.PBKDF2.create();
 10249  	         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
 10250  	         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
 10251  	         */
 10252  	        init: function (cfg) {
 10253  	            this.cfg = this.cfg.extend(cfg);
 10254  	        },
 10255  
 10256  	        /**
 10257  	         * Computes the Password-Based Key Derivation Function 2.
 10258  	         *
 10259  	         * @param {WordArray|string} password The password.
 10260  	         * @param {WordArray|string} salt A salt.
 10261  	         *
 10262  	         * @return {WordArray} The derived key.
 10263  	         *
 10264  	         * @example
 10265  	         *
 10266  	         *     var key = kdf.compute(password, salt);
 10267  	         */
 10268  	        compute: function (password, salt) {
 10269  	            // Shortcut
 10270  	            var cfg = this.cfg;
 10271  
 10272  	            // Init HMAC
 10273  	            var hmac = HMAC.create(cfg.hasher, password);
 10274  
 10275  	            // Initial values
 10276  	            var derivedKey = WordArray.create();
 10277  	            var blockIndex = WordArray.create([0x00000001]);
 10278  
 10279  	            // Shortcuts
 10280  	            var derivedKeyWords = derivedKey.words;
 10281  	            var blockIndexWords = blockIndex.words;
 10282  	            var keySize = cfg.keySize;
 10283  	            var iterations = cfg.iterations;
 10284  
 10285  	            // Generate key
 10286  	            while (derivedKeyWords.length < keySize) {
 10287  	                var block = hmac.update(salt).finalize(blockIndex);
 10288  	                hmac.reset();
 10289  
 10290  	                // Shortcuts
 10291  	                var blockWords = block.words;
 10292  	                var blockWordsLength = blockWords.length;
 10293  
 10294  	                // Iterations
 10295  	                var intermediate = block;
 10296  	                for (var i = 1; i < iterations; i++) {
 10297  	                    intermediate = hmac.finalize(intermediate);
 10298  	                    hmac.reset();
 10299  
 10300  	                    // Shortcut
 10301  	                    var intermediateWords = intermediate.words;
 10302  
 10303  	                    // XOR intermediate with block
 10304  	                    for (var j = 0; j < blockWordsLength; j++) {
 10305  	                        blockWords[j] ^= intermediateWords[j];
 10306  	                    }
 10307  	                }
 10308  
 10309  	                derivedKey.concat(block);
 10310  	                blockIndexWords[0]++;
 10311  	            }
 10312  	            derivedKey.sigBytes = keySize * 4;
 10313  
 10314  	            return derivedKey;
 10315  	        }
 10316  	    });
 10317  
 10318  	    /**
 10319  	     * Computes the Password-Based Key Derivation Function 2.
 10320  	     *
 10321  	     * @param {WordArray|string} password The password.
 10322  	     * @param {WordArray|string} salt A salt.
 10323  	     * @param {Object} cfg (Optional) The configuration options to use for this computation.
 10324  	     *
 10325  	     * @return {WordArray} The derived key.
 10326  	     *
 10327  	     * @static
 10328  	     *
 10329  	     * @example
 10330  	     *
 10331  	     *     var key = CryptoJS.PBKDF2(password, salt);
 10332  	     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });
 10333  	     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });
 10334  	     */
 10335  	    C.PBKDF2 = function (password, salt, cfg) {
 10336  	        return PBKDF2.create(cfg).compute(password, salt);
 10337  	    };
 10338  	}());
 10339  
 10340  
 10341  	return CryptoJS.PBKDF2;
 10342  
 10343  }));
 10344  },{"./core":53,"./hmac":58,"./sha1":77}],73:[function(require,module,exports){
 10345  ;(function (root, factory, undef) {
 10346  	if (typeof exports === "object") {
 10347  		// CommonJS
 10348  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
 10349  	}
 10350  	else if (typeof define === "function" && define.amd) {
 10351  		// AMD
 10352  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
 10353  	}
 10354  	else {
 10355  		// Global (browser)
 10356  		factory(root.CryptoJS);
 10357  	}
 10358  }(this, function (CryptoJS) {
 10359  
 10360  	(function () {
 10361  	    // Shortcuts
 10362  	    var C = CryptoJS;
 10363  	    var C_lib = C.lib;
 10364  	    var StreamCipher = C_lib.StreamCipher;
 10365  	    var C_algo = C.algo;
 10366  
 10367  	    // Reusable objects
 10368  	    var S  = [];
 10369  	    var C_ = [];
 10370  	    var G  = [];
 10371  
 10372  	    /**
 10373  	     * Rabbit stream cipher algorithm.
 10374  	     *
 10375  	     * This is a legacy version that neglected to convert the key to little-endian.
 10376  	     * This error doesn't affect the cipher's security,
 10377  	     * but it does affect its compatibility with other implementations.
 10378  	     */
 10379  	    var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({
 10380  	        _doReset: function () {
 10381  	            // Shortcuts
 10382  	            var K = this._key.words;
 10383  	            var iv = this.cfg.iv;
 10384  
 10385  	            // Generate initial state values
 10386  	            var X = this._X = [
 10387  	                K[0], (K[3] << 16) | (K[2] >>> 16),
 10388  	                K[1], (K[0] << 16) | (K[3] >>> 16),
 10389  	                K[2], (K[1] << 16) | (K[0] >>> 16),
 10390  	                K[3], (K[2] << 16) | (K[1] >>> 16)
 10391  	            ];
 10392  
 10393  	            // Generate initial counter values
 10394  	            var C = this._C = [
 10395  	                (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
 10396  	                (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
 10397  	                (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
 10398  	                (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
 10399  	            ];
 10400  
 10401  	            // Carry bit
 10402  	            this._b = 0;
 10403  
 10404  	            // Iterate the system four times
 10405  	            for (var i = 0; i < 4; i++) {
 10406  	                nextState.call(this);
 10407  	            }
 10408  
 10409  	            // Modify the counters
 10410  	            for (var i = 0; i < 8; i++) {
 10411  	                C[i] ^= X[(i + 4) & 7];
 10412  	            }
 10413  
 10414  	            // IV setup
 10415  	            if (iv) {
 10416  	                // Shortcuts
 10417  	                var IV = iv.words;
 10418  	                var IV_0 = IV[0];
 10419  	                var IV_1 = IV[1];
 10420  
 10421  	                // Generate four subvectors
 10422  	                var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
 10423  	                var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
 10424  	                var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
 10425  	                var i3 = (i2 << 16)  | (i0 & 0x0000ffff);
 10426  
 10427  	                // Modify counter values
 10428  	                C[0] ^= i0;
 10429  	                C[1] ^= i1;
 10430  	                C[2] ^= i2;
 10431  	                C[3] ^= i3;
 10432  	                C[4] ^= i0;
 10433  	                C[5] ^= i1;
 10434  	                C[6] ^= i2;
 10435  	                C[7] ^= i3;
 10436  
 10437  	                // Iterate the system four times
 10438  	                for (var i = 0; i < 4; i++) {
 10439  	                    nextState.call(this);
 10440  	                }
 10441  	            }
 10442  	        },
 10443  
 10444  	        _doProcessBlock: function (M, offset) {
 10445  	            // Shortcut
 10446  	            var X = this._X;
 10447  
 10448  	            // Iterate the system
 10449  	            nextState.call(this);
 10450  
 10451  	            // Generate four keystream words
 10452  	            S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
 10453  	            S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
 10454  	            S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
 10455  	            S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
 10456  
 10457  	            for (var i = 0; i < 4; i++) {
 10458  	                // Swap endian
 10459  	                S[i] = (((S[i] << 8)  | (S[i] >>> 24)) & 0x00ff00ff) |
 10460  	                       (((S[i] << 24) | (S[i] >>> 8))  & 0xff00ff00);
 10461  
 10462  	                // Encrypt
 10463  	                M[offset + i] ^= S[i];
 10464  	            }
 10465  	        },
 10466  
 10467  	        blockSize: 128/32,
 10468  
 10469  	        ivSize: 64/32
 10470  	    });
 10471  
 10472  	    function nextState() {
 10473  	        // Shortcuts
 10474  	        var X = this._X;
 10475  	        var C = this._C;
 10476  
 10477  	        // Save old counter values
 10478  	        for (var i = 0; i < 8; i++) {
 10479  	            C_[i] = C[i];
 10480  	        }
 10481  
 10482  	        // Calculate new counter values
 10483  	        C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
 10484  	        C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
 10485  	        C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
 10486  	        C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
 10487  	        C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
 10488  	        C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
 10489  	        C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
 10490  	        C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
 10491  	        this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
 10492  
 10493  	        // Calculate the g-values
 10494  	        for (var i = 0; i < 8; i++) {
 10495  	            var gx = X[i] + C[i];
 10496  
 10497  	            // Construct high and low argument for squaring
 10498  	            var ga = gx & 0xffff;
 10499  	            var gb = gx >>> 16;
 10500  
 10501  	            // Calculate high and low result of squaring
 10502  	            var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
 10503  	            var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
 10504  
 10505  	            // High XOR low
 10506  	            G[i] = gh ^ gl;
 10507  	        }
 10508  
 10509  	        // Calculate new state values
 10510  	        X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
 10511  	        X[1] = (G[1] + ((G[0] << 8)  | (G[0] >>> 24)) + G[7]) | 0;
 10512  	        X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
 10513  	        X[3] = (G[3] + ((G[2] << 8)  | (G[2] >>> 24)) + G[1]) | 0;
 10514  	        X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
 10515  	        X[5] = (G[5] + ((G[4] << 8)  | (G[4] >>> 24)) + G[3]) | 0;
 10516  	        X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
 10517  	        X[7] = (G[7] + ((G[6] << 8)  | (G[6] >>> 24)) + G[5]) | 0;
 10518  	    }
 10519  
 10520  	    /**
 10521  	     * Shortcut functions to the cipher's object interface.
 10522  	     *
 10523  	     * @example
 10524  	     *
 10525  	     *     var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);
 10526  	     *     var plaintext  = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);
 10527  	     */
 10528  	    C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);
 10529  	}());
 10530  
 10531  
 10532  	return CryptoJS.RabbitLegacy;
 10533  
 10534  }));
 10535  },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],74:[function(require,module,exports){
 10536  ;(function (root, factory, undef) {
 10537  	if (typeof exports === "object") {
 10538  		// CommonJS
 10539  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
 10540  	}
 10541  	else if (typeof define === "function" && define.amd) {
 10542  		// AMD
 10543  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
 10544  	}
 10545  	else {
 10546  		// Global (browser)
 10547  		factory(root.CryptoJS);
 10548  	}
 10549  }(this, function (CryptoJS) {
 10550  
 10551  	(function () {
 10552  	    // Shortcuts
 10553  	    var C = CryptoJS;
 10554  	    var C_lib = C.lib;
 10555  	    var StreamCipher = C_lib.StreamCipher;
 10556  	    var C_algo = C.algo;
 10557  
 10558  	    // Reusable objects
 10559  	    var S  = [];
 10560  	    var C_ = [];
 10561  	    var G  = [];
 10562  
 10563  	    /**
 10564  	     * Rabbit stream cipher algorithm
 10565  	     */
 10566  	    var Rabbit = C_algo.Rabbit = StreamCipher.extend({
 10567  	        _doReset: function () {
 10568  	            // Shortcuts
 10569  	            var K = this._key.words;
 10570  	            var iv = this.cfg.iv;
 10571  
 10572  	            // Swap endian
 10573  	            for (var i = 0; i < 4; i++) {
 10574  	                K[i] = (((K[i] << 8)  | (K[i] >>> 24)) & 0x00ff00ff) |
 10575  	                       (((K[i] << 24) | (K[i] >>> 8))  & 0xff00ff00);
 10576  	            }
 10577  
 10578  	            // Generate initial state values
 10579  	            var X = this._X = [
 10580  	                K[0], (K[3] << 16) | (K[2] >>> 16),
 10581  	                K[1], (K[0] << 16) | (K[3] >>> 16),
 10582  	                K[2], (K[1] << 16) | (K[0] >>> 16),
 10583  	                K[3], (K[2] << 16) | (K[1] >>> 16)
 10584  	            ];
 10585  
 10586  	            // Generate initial counter values
 10587  	            var C = this._C = [
 10588  	                (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
 10589  	                (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
 10590  	                (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
 10591  	                (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
 10592  	            ];
 10593  
 10594  	            // Carry bit
 10595  	            this._b = 0;
 10596  
 10597  	            // Iterate the system four times
 10598  	            for (var i = 0; i < 4; i++) {
 10599  	                nextState.call(this);
 10600  	            }
 10601  
 10602  	            // Modify the counters
 10603  	            for (var i = 0; i < 8; i++) {
 10604  	                C[i] ^= X[(i + 4) & 7];
 10605  	            }
 10606  
 10607  	            // IV setup
 10608  	            if (iv) {
 10609  	                // Shortcuts
 10610  	                var IV = iv.words;
 10611  	                var IV_0 = IV[0];
 10612  	                var IV_1 = IV[1];
 10613  
 10614  	                // Generate four subvectors
 10615  	                var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
 10616  	                var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
 10617  	                var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
 10618  	                var i3 = (i2 << 16)  | (i0 & 0x0000ffff);
 10619  
 10620  	                // Modify counter values
 10621  	                C[0] ^= i0;
 10622  	                C[1] ^= i1;
 10623  	                C[2] ^= i2;
 10624  	                C[3] ^= i3;
 10625  	                C[4] ^= i0;
 10626  	                C[5] ^= i1;
 10627  	                C[6] ^= i2;
 10628  	                C[7] ^= i3;
 10629  
 10630  	                // Iterate the system four times
 10631  	                for (var i = 0; i < 4; i++) {
 10632  	                    nextState.call(this);
 10633  	                }
 10634  	            }
 10635  	        },
 10636  
 10637  	        _doProcessBlock: function (M, offset) {
 10638  	            // Shortcut
 10639  	            var X = this._X;
 10640  
 10641  	            // Iterate the system
 10642  	            nextState.call(this);
 10643  
 10644  	            // Generate four keystream words
 10645  	            S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
 10646  	            S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
 10647  	            S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
 10648  	            S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
 10649  
 10650  	            for (var i = 0; i < 4; i++) {
 10651  	                // Swap endian
 10652  	                S[i] = (((S[i] << 8)  | (S[i] >>> 24)) & 0x00ff00ff) |
 10653  	                       (((S[i] << 24) | (S[i] >>> 8))  & 0xff00ff00);
 10654  
 10655  	                // Encrypt
 10656  	                M[offset + i] ^= S[i];
 10657  	            }
 10658  	        },
 10659  
 10660  	        blockSize: 128/32,
 10661  
 10662  	        ivSize: 64/32
 10663  	    });
 10664  
 10665  	    function nextState() {
 10666  	        // Shortcuts
 10667  	        var X = this._X;
 10668  	        var C = this._C;
 10669  
 10670  	        // Save old counter values
 10671  	        for (var i = 0; i < 8; i++) {
 10672  	            C_[i] = C[i];
 10673  	        }
 10674  
 10675  	        // Calculate new counter values
 10676  	        C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
 10677  	        C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
 10678  	        C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
 10679  	        C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
 10680  	        C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
 10681  	        C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
 10682  	        C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
 10683  	        C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
 10684  	        this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
 10685  
 10686  	        // Calculate the g-values
 10687  	        for (var i = 0; i < 8; i++) {
 10688  	            var gx = X[i] + C[i];
 10689  
 10690  	            // Construct high and low argument for squaring
 10691  	            var ga = gx & 0xffff;
 10692  	            var gb = gx >>> 16;
 10693  
 10694  	            // Calculate high and low result of squaring
 10695  	            var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
 10696  	            var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
 10697  
 10698  	            // High XOR low
 10699  	            G[i] = gh ^ gl;
 10700  	        }
 10701  
 10702  	        // Calculate new state values
 10703  	        X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
 10704  	        X[1] = (G[1] + ((G[0] << 8)  | (G[0] >>> 24)) + G[7]) | 0;
 10705  	        X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
 10706  	        X[3] = (G[3] + ((G[2] << 8)  | (G[2] >>> 24)) + G[1]) | 0;
 10707  	        X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
 10708  	        X[5] = (G[5] + ((G[4] << 8)  | (G[4] >>> 24)) + G[3]) | 0;
 10709  	        X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
 10710  	        X[7] = (G[7] + ((G[6] << 8)  | (G[6] >>> 24)) + G[5]) | 0;
 10711  	    }
 10712  
 10713  	    /**
 10714  	     * Shortcut functions to the cipher's object interface.
 10715  	     *
 10716  	     * @example
 10717  	     *
 10718  	     *     var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg);
 10719  	     *     var plaintext  = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg);
 10720  	     */
 10721  	    C.Rabbit = StreamCipher._createHelper(Rabbit);
 10722  	}());
 10723  
 10724  
 10725  	return CryptoJS.Rabbit;
 10726  
 10727  }));
 10728  },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],75:[function(require,module,exports){
 10729  ;(function (root, factory, undef) {
 10730  	if (typeof exports === "object") {
 10731  		// CommonJS
 10732  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
 10733  	}
 10734  	else if (typeof define === "function" && define.amd) {
 10735  		// AMD
 10736  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
 10737  	}
 10738  	else {
 10739  		// Global (browser)
 10740  		factory(root.CryptoJS);
 10741  	}
 10742  }(this, function (CryptoJS) {
 10743  
 10744  	(function () {
 10745  	    // Shortcuts
 10746  	    var C = CryptoJS;
 10747  	    var C_lib = C.lib;
 10748  	    var StreamCipher = C_lib.StreamCipher;
 10749  	    var C_algo = C.algo;
 10750  
 10751  	    /**
 10752  	     * RC4 stream cipher algorithm.
 10753  	     */
 10754  	    var RC4 = C_algo.RC4 = StreamCipher.extend({
 10755  	        _doReset: function () {
 10756  	            // Shortcuts
 10757  	            var key = this._key;
 10758  	            var keyWords = key.words;
 10759  	            var keySigBytes = key.sigBytes;
 10760  
 10761  	            // Init sbox
 10762  	            var S = this._S = [];
 10763  	            for (var i = 0; i < 256; i++) {
 10764  	                S[i] = i;
 10765  	            }
 10766  
 10767  	            // Key setup
 10768  	            for (var i = 0, j = 0; i < 256; i++) {
 10769  	                var keyByteIndex = i % keySigBytes;
 10770  	                var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff;
 10771  
 10772  	                j = (j + S[i] + keyByte) % 256;
 10773  
 10774  	                // Swap
 10775  	                var t = S[i];
 10776  	                S[i] = S[j];
 10777  	                S[j] = t;
 10778  	            }
 10779  
 10780  	            // Counters
 10781  	            this._i = this._j = 0;
 10782  	        },
 10783  
 10784  	        _doProcessBlock: function (M, offset) {
 10785  	            M[offset] ^= generateKeystreamWord.call(this);
 10786  	        },
 10787  
 10788  	        keySize: 256/32,
 10789  
 10790  	        ivSize: 0
 10791  	    });
 10792  
 10793  	    function generateKeystreamWord() {
 10794  	        // Shortcuts
 10795  	        var S = this._S;
 10796  	        var i = this._i;
 10797  	        var j = this._j;
 10798  
 10799  	        // Generate keystream word
 10800  	        var keystreamWord = 0;
 10801  	        for (var n = 0; n < 4; n++) {
 10802  	            i = (i + 1) % 256;
 10803  	            j = (j + S[i]) % 256;
 10804  
 10805  	            // Swap
 10806  	            var t = S[i];
 10807  	            S[i] = S[j];
 10808  	            S[j] = t;
 10809  
 10810  	            keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8);
 10811  	        }
 10812  
 10813  	        // Update counters
 10814  	        this._i = i;
 10815  	        this._j = j;
 10816  
 10817  	        return keystreamWord;
 10818  	    }
 10819  
 10820  	    /**
 10821  	     * Shortcut functions to the cipher's object interface.
 10822  	     *
 10823  	     * @example
 10824  	     *
 10825  	     *     var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg);
 10826  	     *     var plaintext  = CryptoJS.RC4.decrypt(ciphertext, key, cfg);
 10827  	     */
 10828  	    C.RC4 = StreamCipher._createHelper(RC4);
 10829  
 10830  	    /**
 10831  	     * Modified RC4 stream cipher algorithm.
 10832  	     */
 10833  	    var RC4Drop = C_algo.RC4Drop = RC4.extend({
 10834  	        /**
 10835  	         * Configuration options.
 10836  	         *
 10837  	         * @property {number} drop The number of keystream words to drop. Default 192
 10838  	         */
 10839  	        cfg: RC4.cfg.extend({
 10840  	            drop: 192
 10841  	        }),
 10842  
 10843  	        _doReset: function () {
 10844  	            RC4._doReset.call(this);
 10845  
 10846  	            // Drop
 10847  	            for (var i = this.cfg.drop; i > 0; i--) {
 10848  	                generateKeystreamWord.call(this);
 10849  	            }
 10850  	        }
 10851  	    });
 10852  
 10853  	    /**
 10854  	     * Shortcut functions to the cipher's object interface.
 10855  	     *
 10856  	     * @example
 10857  	     *
 10858  	     *     var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg);
 10859  	     *     var plaintext  = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg);
 10860  	     */
 10861  	    C.RC4Drop = StreamCipher._createHelper(RC4Drop);
 10862  	}());
 10863  
 10864  
 10865  	return CryptoJS.RC4;
 10866  
 10867  }));
 10868  },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],76:[function(require,module,exports){
 10869  ;(function (root, factory) {
 10870  	if (typeof exports === "object") {
 10871  		// CommonJS
 10872  		module.exports = exports = factory(require("./core"));
 10873  	}
 10874  	else if (typeof define === "function" && define.amd) {
 10875  		// AMD
 10876  		define(["./core"], factory);
 10877  	}
 10878  	else {
 10879  		// Global (browser)
 10880  		factory(root.CryptoJS);
 10881  	}
 10882  }(this, function (CryptoJS) {
 10883  
 10884  	/** @preserve
 10885  	(c) 2012 by Cédric Mesnil. All rights reserved.
 10886  
 10887  	Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 10888  
 10889  	    - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 10890  	    - 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.
 10891  
 10892  	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE 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.
 10893  	*/
 10894  
 10895  	(function (Math) {
 10896  	    // Shortcuts
 10897  	    var C = CryptoJS;
 10898  	    var C_lib = C.lib;
 10899  	    var WordArray = C_lib.WordArray;
 10900  	    var Hasher = C_lib.Hasher;
 10901  	    var C_algo = C.algo;
 10902  
 10903  	    // Constants table
 10904  	    var _zl = WordArray.create([
 10905  	        0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 10906  	        7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
 10907  	        3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
 10908  	        1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
 10909  	        4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13]);
 10910  	    var _zr = WordArray.create([
 10911  	        5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
 10912  	        6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
 10913  	        15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
 10914  	        8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
 10915  	        12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11]);
 10916  	    var _sl = WordArray.create([
 10917  	         11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
 10918  	        7, 6,   8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
 10919  	        11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
 10920  	          11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
 10921  	        9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6 ]);
 10922  	    var _sr = WordArray.create([
 10923  	        8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
 10924  	        9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
 10925  	        9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
 10926  	        15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
 10927  	        8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11 ]);
 10928  
 10929  	    var _hl =  WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);
 10930  	    var _hr =  WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);
 10931  
 10932  	    /**
 10933  	     * RIPEMD160 hash algorithm.
 10934  	     */
 10935  	    var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({
 10936  	        _doReset: function () {
 10937  	            this._hash  = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);
 10938  	        },
 10939  
 10940  	        _doProcessBlock: function (M, offset) {
 10941  
 10942  	            // Swap endian
 10943  	            for (var i = 0; i < 16; i++) {
 10944  	                // Shortcuts
 10945  	                var offset_i = offset + i;
 10946  	                var M_offset_i = M[offset_i];
 10947  
 10948  	                // Swap
 10949  	                M[offset_i] = (
 10950  	                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
 10951  	                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
 10952  	                );
 10953  	            }
 10954  	            // Shortcut
 10955  	            var H  = this._hash.words;
 10956  	            var hl = _hl.words;
 10957  	            var hr = _hr.words;
 10958  	            var zl = _zl.words;
 10959  	            var zr = _zr.words;
 10960  	            var sl = _sl.words;
 10961  	            var sr = _sr.words;
 10962  
 10963  	            // Working variables
 10964  	            var al, bl, cl, dl, el;
 10965  	            var ar, br, cr, dr, er;
 10966  
 10967  	            ar = al = H[0];
 10968  	            br = bl = H[1];
 10969  	            cr = cl = H[2];
 10970  	            dr = dl = H[3];
 10971  	            er = el = H[4];
 10972  	            // Computation
 10973  	            var t;
 10974  	            for (var i = 0; i < 80; i += 1) {
 10975  	                t = (al +  M[offset+zl[i]])|0;
 10976  	                if (i<16){
 10977  		            t +=  f1(bl,cl,dl) + hl[0];
 10978  	                } else if (i<32) {
 10979  		            t +=  f2(bl,cl,dl) + hl[1];
 10980  	                } else if (i<48) {
 10981  		            t +=  f3(bl,cl,dl) + hl[2];
 10982  	                } else if (i<64) {
 10983  		            t +=  f4(bl,cl,dl) + hl[3];
 10984  	                } else {// if (i<80) {
 10985  		            t +=  f5(bl,cl,dl) + hl[4];
 10986  	                }
 10987  	                t = t|0;
 10988  	                t =  rotl(t,sl[i]);
 10989  	                t = (t+el)|0;
 10990  	                al = el;
 10991  	                el = dl;
 10992  	                dl = rotl(cl, 10);
 10993  	                cl = bl;
 10994  	                bl = t;
 10995  
 10996  	                t = (ar + M[offset+zr[i]])|0;
 10997  	                if (i<16){
 10998  		            t +=  f5(br,cr,dr) + hr[0];
 10999  	                } else if (i<32) {
 11000  		            t +=  f4(br,cr,dr) + hr[1];
 11001  	                } else if (i<48) {
 11002  		            t +=  f3(br,cr,dr) + hr[2];
 11003  	                } else if (i<64) {
 11004  		            t +=  f2(br,cr,dr) + hr[3];
 11005  	                } else {// if (i<80) {
 11006  		            t +=  f1(br,cr,dr) + hr[4];
 11007  	                }
 11008  	                t = t|0;
 11009  	                t =  rotl(t,sr[i]) ;
 11010  	                t = (t+er)|0;
 11011  	                ar = er;
 11012  	                er = dr;
 11013  	                dr = rotl(cr, 10);
 11014  	                cr = br;
 11015  	                br = t;
 11016  	            }
 11017  	            // Intermediate hash value
 11018  	            t    = (H[1] + cl + dr)|0;
 11019  	            H[1] = (H[2] + dl + er)|0;
 11020  	            H[2] = (H[3] + el + ar)|0;
 11021  	            H[3] = (H[4] + al + br)|0;
 11022  	            H[4] = (H[0] + bl + cr)|0;
 11023  	            H[0] =  t;
 11024  	        },
 11025  
 11026  	        _doFinalize: function () {
 11027  	            // Shortcuts
 11028  	            var data = this._data;
 11029  	            var dataWords = data.words;
 11030  
 11031  	            var nBitsTotal = this._nDataBytes * 8;
 11032  	            var nBitsLeft = data.sigBytes * 8;
 11033  
 11034  	            // Add padding
 11035  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
 11036  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
 11037  	                (((nBitsTotal << 8)  | (nBitsTotal >>> 24)) & 0x00ff00ff) |
 11038  	                (((nBitsTotal << 24) | (nBitsTotal >>> 8))  & 0xff00ff00)
 11039  	            );
 11040  	            data.sigBytes = (dataWords.length + 1) * 4;
 11041  
 11042  	            // Hash final blocks
 11043  	            this._process();
 11044  
 11045  	            // Shortcuts
 11046  	            var hash = this._hash;
 11047  	            var H = hash.words;
 11048  
 11049  	            // Swap endian
 11050  	            for (var i = 0; i < 5; i++) {
 11051  	                // Shortcut
 11052  	                var H_i = H[i];
 11053  
 11054  	                // Swap
 11055  	                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
 11056  	                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
 11057  	            }
 11058  
 11059  	            // Return final computed hash
 11060  	            return hash;
 11061  	        },
 11062  
 11063  	        clone: function () {
 11064  	            var clone = Hasher.clone.call(this);
 11065  	            clone._hash = this._hash.clone();
 11066  
 11067  	            return clone;
 11068  	        }
 11069  	    });
 11070  
 11071  
 11072  	    function f1(x, y, z) {
 11073  	        return ((x) ^ (y) ^ (z));
 11074  
 11075  	    }
 11076  
 11077  	    function f2(x, y, z) {
 11078  	        return (((x)&(y)) | ((~x)&(z)));
 11079  	    }
 11080  
 11081  	    function f3(x, y, z) {
 11082  	        return (((x) | (~(y))) ^ (z));
 11083  	    }
 11084  
 11085  	    function f4(x, y, z) {
 11086  	        return (((x) & (z)) | ((y)&(~(z))));
 11087  	    }
 11088  
 11089  	    function f5(x, y, z) {
 11090  	        return ((x) ^ ((y) |(~(z))));
 11091  
 11092  	    }
 11093  
 11094  	    function rotl(x,n) {
 11095  	        return (x<<n) | (x>>>(32-n));
 11096  	    }
 11097  
 11098  
 11099  	    /**
 11100  	     * Shortcut function to the hasher's object interface.
 11101  	     *
 11102  	     * @param {WordArray|string} message The message to hash.
 11103  	     *
 11104  	     * @return {WordArray} The hash.
 11105  	     *
 11106  	     * @static
 11107  	     *
 11108  	     * @example
 11109  	     *
 11110  	     *     var hash = CryptoJS.RIPEMD160('message');
 11111  	     *     var hash = CryptoJS.RIPEMD160(wordArray);
 11112  	     */
 11113  	    C.RIPEMD160 = Hasher._createHelper(RIPEMD160);
 11114  
 11115  	    /**
 11116  	     * Shortcut function to the HMAC's object interface.
 11117  	     *
 11118  	     * @param {WordArray|string} message The message to hash.
 11119  	     * @param {WordArray|string} key The secret key.
 11120  	     *
 11121  	     * @return {WordArray} The HMAC.
 11122  	     *
 11123  	     * @static
 11124  	     *
 11125  	     * @example
 11126  	     *
 11127  	     *     var hmac = CryptoJS.HmacRIPEMD160(message, key);
 11128  	     */
 11129  	    C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160);
 11130  	}(Math));
 11131  
 11132  
 11133  	return CryptoJS.RIPEMD160;
 11134  
 11135  }));
 11136  },{"./core":53}],77:[function(require,module,exports){
 11137  ;(function (root, factory) {
 11138  	if (typeof exports === "object") {
 11139  		// CommonJS
 11140  		module.exports = exports = factory(require("./core"));
 11141  	}
 11142  	else if (typeof define === "function" && define.amd) {
 11143  		// AMD
 11144  		define(["./core"], factory);
 11145  	}
 11146  	else {
 11147  		// Global (browser)
 11148  		factory(root.CryptoJS);
 11149  	}
 11150  }(this, function (CryptoJS) {
 11151  
 11152  	(function () {
 11153  	    // Shortcuts
 11154  	    var C = CryptoJS;
 11155  	    var C_lib = C.lib;
 11156  	    var WordArray = C_lib.WordArray;
 11157  	    var Hasher = C_lib.Hasher;
 11158  	    var C_algo = C.algo;
 11159  
 11160  	    // Reusable object
 11161  	    var W = [];
 11162  
 11163  	    /**
 11164  	     * SHA-1 hash algorithm.
 11165  	     */
 11166  	    var SHA1 = C_algo.SHA1 = Hasher.extend({
 11167  	        _doReset: function () {
 11168  	            this._hash = new WordArray.init([
 11169  	                0x67452301, 0xefcdab89,
 11170  	                0x98badcfe, 0x10325476,
 11171  	                0xc3d2e1f0
 11172  	            ]);
 11173  	        },
 11174  
 11175  	        _doProcessBlock: function (M, offset) {
 11176  	            // Shortcut
 11177  	            var H = this._hash.words;
 11178  
 11179  	            // Working variables
 11180  	            var a = H[0];
 11181  	            var b = H[1];
 11182  	            var c = H[2];
 11183  	            var d = H[3];
 11184  	            var e = H[4];
 11185  
 11186  	            // Computation
 11187  	            for (var i = 0; i < 80; i++) {
 11188  	                if (i < 16) {
 11189  	                    W[i] = M[offset + i] | 0;
 11190  	                } else {
 11191  	                    var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
 11192  	                    W[i] = (n << 1) | (n >>> 31);
 11193  	                }
 11194  
 11195  	                var t = ((a << 5) | (a >>> 27)) + e + W[i];
 11196  	                if (i < 20) {
 11197  	                    t += ((b & c) | (~b & d)) + 0x5a827999;
 11198  	                } else if (i < 40) {
 11199  	                    t += (b ^ c ^ d) + 0x6ed9eba1;
 11200  	                } else if (i < 60) {
 11201  	                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
 11202  	                } else /* if (i < 80) */ {
 11203  	                    t += (b ^ c ^ d) - 0x359d3e2a;
 11204  	                }
 11205  
 11206  	                e = d;
 11207  	                d = c;
 11208  	                c = (b << 30) | (b >>> 2);
 11209  	                b = a;
 11210  	                a = t;
 11211  	            }
 11212  
 11213  	            // Intermediate hash value
 11214  	            H[0] = (H[0] + a) | 0;
 11215  	            H[1] = (H[1] + b) | 0;
 11216  	            H[2] = (H[2] + c) | 0;
 11217  	            H[3] = (H[3] + d) | 0;
 11218  	            H[4] = (H[4] + e) | 0;
 11219  	        },
 11220  
 11221  	        _doFinalize: function () {
 11222  	            // Shortcuts
 11223  	            var data = this._data;
 11224  	            var dataWords = data.words;
 11225  
 11226  	            var nBitsTotal = this._nDataBytes * 8;
 11227  	            var nBitsLeft = data.sigBytes * 8;
 11228  
 11229  	            // Add padding
 11230  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
 11231  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
 11232  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
 11233  	            data.sigBytes = dataWords.length * 4;
 11234  
 11235  	            // Hash final blocks
 11236  	            this._process();
 11237  
 11238  	            // Return final computed hash
 11239  	            return this._hash;
 11240  	        },
 11241  
 11242  	        clone: function () {
 11243  	            var clone = Hasher.clone.call(this);
 11244  	            clone._hash = this._hash.clone();
 11245  
 11246  	            return clone;
 11247  	        }
 11248  	    });
 11249  
 11250  	    /**
 11251  	     * Shortcut function to the hasher's object interface.
 11252  	     *
 11253  	     * @param {WordArray|string} message The message to hash.
 11254  	     *
 11255  	     * @return {WordArray} The hash.
 11256  	     *
 11257  	     * @static
 11258  	     *
 11259  	     * @example
 11260  	     *
 11261  	     *     var hash = CryptoJS.SHA1('message');
 11262  	     *     var hash = CryptoJS.SHA1(wordArray);
 11263  	     */
 11264  	    C.SHA1 = Hasher._createHelper(SHA1);
 11265  
 11266  	    /**
 11267  	     * Shortcut function to the HMAC's object interface.
 11268  	     *
 11269  	     * @param {WordArray|string} message The message to hash.
 11270  	     * @param {WordArray|string} key The secret key.
 11271  	     *
 11272  	     * @return {WordArray} The HMAC.
 11273  	     *
 11274  	     * @static
 11275  	     *
 11276  	     * @example
 11277  	     *
 11278  	     *     var hmac = CryptoJS.HmacSHA1(message, key);
 11279  	     */
 11280  	    C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
 11281  	}());
 11282  
 11283  
 11284  	return CryptoJS.SHA1;
 11285  
 11286  }));
 11287  },{"./core":53}],78:[function(require,module,exports){
 11288  ;(function (root, factory, undef) {
 11289  	if (typeof exports === "object") {
 11290  		// CommonJS
 11291  		module.exports = exports = factory(require("./core"), require("./sha256"));
 11292  	}
 11293  	else if (typeof define === "function" && define.amd) {
 11294  		// AMD
 11295  		define(["./core", "./sha256"], factory);
 11296  	}
 11297  	else {
 11298  		// Global (browser)
 11299  		factory(root.CryptoJS);
 11300  	}
 11301  }(this, function (CryptoJS) {
 11302  
 11303  	(function () {
 11304  	    // Shortcuts
 11305  	    var C = CryptoJS;
 11306  	    var C_lib = C.lib;
 11307  	    var WordArray = C_lib.WordArray;
 11308  	    var C_algo = C.algo;
 11309  	    var SHA256 = C_algo.SHA256;
 11310  
 11311  	    /**
 11312  	     * SHA-224 hash algorithm.
 11313  	     */
 11314  	    var SHA224 = C_algo.SHA224 = SHA256.extend({
 11315  	        _doReset: function () {
 11316  	            this._hash = new WordArray.init([
 11317  	                0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
 11318  	                0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
 11319  	            ]);
 11320  	        },
 11321  
 11322  	        _doFinalize: function () {
 11323  	            var hash = SHA256._doFinalize.call(this);
 11324  
 11325  	            hash.sigBytes -= 4;
 11326  
 11327  	            return hash;
 11328  	        }
 11329  	    });
 11330  
 11331  	    /**
 11332  	     * Shortcut function to the hasher's object interface.
 11333  	     *
 11334  	     * @param {WordArray|string} message The message to hash.
 11335  	     *
 11336  	     * @return {WordArray} The hash.
 11337  	     *
 11338  	     * @static
 11339  	     *
 11340  	     * @example
 11341  	     *
 11342  	     *     var hash = CryptoJS.SHA224('message');
 11343  	     *     var hash = CryptoJS.SHA224(wordArray);
 11344  	     */
 11345  	    C.SHA224 = SHA256._createHelper(SHA224);
 11346  
 11347  	    /**
 11348  	     * Shortcut function to the HMAC's object interface.
 11349  	     *
 11350  	     * @param {WordArray|string} message The message to hash.
 11351  	     * @param {WordArray|string} key The secret key.
 11352  	     *
 11353  	     * @return {WordArray} The HMAC.
 11354  	     *
 11355  	     * @static
 11356  	     *
 11357  	     * @example
 11358  	     *
 11359  	     *     var hmac = CryptoJS.HmacSHA224(message, key);
 11360  	     */
 11361  	    C.HmacSHA224 = SHA256._createHmacHelper(SHA224);
 11362  	}());
 11363  
 11364  
 11365  	return CryptoJS.SHA224;
 11366  
 11367  }));
 11368  },{"./core":53,"./sha256":79}],79:[function(require,module,exports){
 11369  ;(function (root, factory) {
 11370  	if (typeof exports === "object") {
 11371  		// CommonJS
 11372  		module.exports = exports = factory(require("./core"));
 11373  	}
 11374  	else if (typeof define === "function" && define.amd) {
 11375  		// AMD
 11376  		define(["./core"], factory);
 11377  	}
 11378  	else {
 11379  		// Global (browser)
 11380  		factory(root.CryptoJS);
 11381  	}
 11382  }(this, function (CryptoJS) {
 11383  
 11384  	(function (Math) {
 11385  	    // Shortcuts
 11386  	    var C = CryptoJS;
 11387  	    var C_lib = C.lib;
 11388  	    var WordArray = C_lib.WordArray;
 11389  	    var Hasher = C_lib.Hasher;
 11390  	    var C_algo = C.algo;
 11391  
 11392  	    // Initialization and round constants tables
 11393  	    var H = [];
 11394  	    var K = [];
 11395  
 11396  	    // Compute constants
 11397  	    (function () {
 11398  	        function isPrime(n) {
 11399  	            var sqrtN = Math.sqrt(n);
 11400  	            for (var factor = 2; factor <= sqrtN; factor++) {
 11401  	                if (!(n % factor)) {
 11402  	                    return false;
 11403  	                }
 11404  	            }
 11405  
 11406  	            return true;
 11407  	        }
 11408  
 11409  	        function getFractionalBits(n) {
 11410  	            return ((n - (n | 0)) * 0x100000000) | 0;
 11411  	        }
 11412  
 11413  	        var n = 2;
 11414  	        var nPrime = 0;
 11415  	        while (nPrime < 64) {
 11416  	            if (isPrime(n)) {
 11417  	                if (nPrime < 8) {
 11418  	                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
 11419  	                }
 11420  	                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
 11421  
 11422  	                nPrime++;
 11423  	            }
 11424  
 11425  	            n++;
 11426  	        }
 11427  	    }());
 11428  
 11429  	    // Reusable object
 11430  	    var W = [];
 11431  
 11432  	    /**
 11433  	     * SHA-256 hash algorithm.
 11434  	     */
 11435  	    var SHA256 = C_algo.SHA256 = Hasher.extend({
 11436  	        _doReset: function () {
 11437  	            this._hash = new WordArray.init(H.slice(0));
 11438  	        },
 11439  
 11440  	        _doProcessBlock: function (M, offset) {
 11441  	            // Shortcut
 11442  	            var H = this._hash.words;
 11443  
 11444  	            // Working variables
 11445  	            var a = H[0];
 11446  	            var b = H[1];
 11447  	            var c = H[2];
 11448  	            var d = H[3];
 11449  	            var e = H[4];
 11450  	            var f = H[5];
 11451  	            var g = H[6];
 11452  	            var h = H[7];
 11453  
 11454  	            // Computation
 11455  	            for (var i = 0; i < 64; i++) {
 11456  	                if (i < 16) {
 11457  	                    W[i] = M[offset + i] | 0;
 11458  	                } else {
 11459  	                    var gamma0x = W[i - 15];
 11460  	                    var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^
 11461  	                                  ((gamma0x << 14) | (gamma0x >>> 18)) ^
 11462  	                                   (gamma0x >>> 3);
 11463  
 11464  	                    var gamma1x = W[i - 2];
 11465  	                    var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^
 11466  	                                  ((gamma1x << 13) | (gamma1x >>> 19)) ^
 11467  	                                   (gamma1x >>> 10);
 11468  
 11469  	                    W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
 11470  	                }
 11471  
 11472  	                var ch  = (e & f) ^ (~e & g);
 11473  	                var maj = (a & b) ^ (a & c) ^ (b & c);
 11474  
 11475  	                var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
 11476  	                var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));
 11477  
 11478  	                var t1 = h + sigma1 + ch + K[i] + W[i];
 11479  	                var t2 = sigma0 + maj;
 11480  
 11481  	                h = g;
 11482  	                g = f;
 11483  	                f = e;
 11484  	                e = (d + t1) | 0;
 11485  	                d = c;
 11486  	                c = b;
 11487  	                b = a;
 11488  	                a = (t1 + t2) | 0;
 11489  	            }
 11490  
 11491  	            // Intermediate hash value
 11492  	            H[0] = (H[0] + a) | 0;
 11493  	            H[1] = (H[1] + b) | 0;
 11494  	            H[2] = (H[2] + c) | 0;
 11495  	            H[3] = (H[3] + d) | 0;
 11496  	            H[4] = (H[4] + e) | 0;
 11497  	            H[5] = (H[5] + f) | 0;
 11498  	            H[6] = (H[6] + g) | 0;
 11499  	            H[7] = (H[7] + h) | 0;
 11500  	        },
 11501  
 11502  	        _doFinalize: function () {
 11503  	            // Shortcuts
 11504  	            var data = this._data;
 11505  	            var dataWords = data.words;
 11506  
 11507  	            var nBitsTotal = this._nDataBytes * 8;
 11508  	            var nBitsLeft = data.sigBytes * 8;
 11509  
 11510  	            // Add padding
 11511  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
 11512  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
 11513  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
 11514  	            data.sigBytes = dataWords.length * 4;
 11515  
 11516  	            // Hash final blocks
 11517  	            this._process();
 11518  
 11519  	            // Return final computed hash
 11520  	            return this._hash;
 11521  	        },
 11522  
 11523  	        clone: function () {
 11524  	            var clone = Hasher.clone.call(this);
 11525  	            clone._hash = this._hash.clone();
 11526  
 11527  	            return clone;
 11528  	        }
 11529  	    });
 11530  
 11531  	    /**
 11532  	     * Shortcut function to the hasher's object interface.
 11533  	     *
 11534  	     * @param {WordArray|string} message The message to hash.
 11535  	     *
 11536  	     * @return {WordArray} The hash.
 11537  	     *
 11538  	     * @static
 11539  	     *
 11540  	     * @example
 11541  	     *
 11542  	     *     var hash = CryptoJS.SHA256('message');
 11543  	     *     var hash = CryptoJS.SHA256(wordArray);
 11544  	     */
 11545  	    C.SHA256 = Hasher._createHelper(SHA256);
 11546  
 11547  	    /**
 11548  	     * Shortcut function to the HMAC's object interface.
 11549  	     *
 11550  	     * @param {WordArray|string} message The message to hash.
 11551  	     * @param {WordArray|string} key The secret key.
 11552  	     *
 11553  	     * @return {WordArray} The HMAC.
 11554  	     *
 11555  	     * @static
 11556  	     *
 11557  	     * @example
 11558  	     *
 11559  	     *     var hmac = CryptoJS.HmacSHA256(message, key);
 11560  	     */
 11561  	    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
 11562  	}(Math));
 11563  
 11564  
 11565  	return CryptoJS.SHA256;
 11566  
 11567  }));
 11568  },{"./core":53}],80:[function(require,module,exports){
 11569  ;(function (root, factory, undef) {
 11570  	if (typeof exports === "object") {
 11571  		// CommonJS
 11572  		module.exports = exports = factory(require("./core"), require("./x64-core"));
 11573  	}
 11574  	else if (typeof define === "function" && define.amd) {
 11575  		// AMD
 11576  		define(["./core", "./x64-core"], factory);
 11577  	}
 11578  	else {
 11579  		// Global (browser)
 11580  		factory(root.CryptoJS);
 11581  	}
 11582  }(this, function (CryptoJS) {
 11583  
 11584  	(function (Math) {
 11585  	    // Shortcuts
 11586  	    var C = CryptoJS;
 11587  	    var C_lib = C.lib;
 11588  	    var WordArray = C_lib.WordArray;
 11589  	    var Hasher = C_lib.Hasher;
 11590  	    var C_x64 = C.x64;
 11591  	    var X64Word = C_x64.Word;
 11592  	    var C_algo = C.algo;
 11593  
 11594  	    // Constants tables
 11595  	    var RHO_OFFSETS = [];
 11596  	    var PI_INDEXES  = [];
 11597  	    var ROUND_CONSTANTS = [];
 11598  
 11599  	    // Compute Constants
 11600  	    (function () {
 11601  	        // Compute rho offset constants
 11602  	        var x = 1, y = 0;
 11603  	        for (var t = 0; t < 24; t++) {
 11604  	            RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64;
 11605  
 11606  	            var newX = y % 5;
 11607  	            var newY = (2 * x + 3 * y) % 5;
 11608  	            x = newX;
 11609  	            y = newY;
 11610  	        }
 11611  
 11612  	        // Compute pi index constants
 11613  	        for (var x = 0; x < 5; x++) {
 11614  	            for (var y = 0; y < 5; y++) {
 11615  	                PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;
 11616  	            }
 11617  	        }
 11618  
 11619  	        // Compute round constants
 11620  	        var LFSR = 0x01;
 11621  	        for (var i = 0; i < 24; i++) {
 11622  	            var roundConstantMsw = 0;
 11623  	            var roundConstantLsw = 0;
 11624  
 11625  	            for (var j = 0; j < 7; j++) {
 11626  	                if (LFSR & 0x01) {
 11627  	                    var bitPosition = (1 << j) - 1;
 11628  	                    if (bitPosition < 32) {
 11629  	                        roundConstantLsw ^= 1 << bitPosition;
 11630  	                    } else /* if (bitPosition >= 32) */ {
 11631  	                        roundConstantMsw ^= 1 << (bitPosition - 32);
 11632  	                    }
 11633  	                }
 11634  
 11635  	                // Compute next LFSR
 11636  	                if (LFSR & 0x80) {
 11637  	                    // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
 11638  	                    LFSR = (LFSR << 1) ^ 0x71;
 11639  	                } else {
 11640  	                    LFSR <<= 1;
 11641  	                }
 11642  	            }
 11643  
 11644  	            ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
 11645  	        }
 11646  	    }());
 11647  
 11648  	    // Reusable objects for temporary values
 11649  	    var T = [];
 11650  	    (function () {
 11651  	        for (var i = 0; i < 25; i++) {
 11652  	            T[i] = X64Word.create();
 11653  	        }
 11654  	    }());
 11655  
 11656  	    /**
 11657  	     * SHA-3 hash algorithm.
 11658  	     */
 11659  	    var SHA3 = C_algo.SHA3 = Hasher.extend({
 11660  	        /**
 11661  	         * Configuration options.
 11662  	         *
 11663  	         * @property {number} outputLength
 11664  	         *   The desired number of bits in the output hash.
 11665  	         *   Only values permitted are: 224, 256, 384, 512.
 11666  	         *   Default: 512
 11667  	         */
 11668  	        cfg: Hasher.cfg.extend({
 11669  	            outputLength: 512
 11670  	        }),
 11671  
 11672  	        _doReset: function () {
 11673  	            var state = this._state = []
 11674  	            for (var i = 0; i < 25; i++) {
 11675  	                state[i] = new X64Word.init();
 11676  	            }
 11677  
 11678  	            this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
 11679  	        },
 11680  
 11681  	        _doProcessBlock: function (M, offset) {
 11682  	            // Shortcuts
 11683  	            var state = this._state;
 11684  	            var nBlockSizeLanes = this.blockSize / 2;
 11685  
 11686  	            // Absorb
 11687  	            for (var i = 0; i < nBlockSizeLanes; i++) {
 11688  	                // Shortcuts
 11689  	                var M2i  = M[offset + 2 * i];
 11690  	                var M2i1 = M[offset + 2 * i + 1];
 11691  
 11692  	                // Swap endian
 11693  	                M2i = (
 11694  	                    (((M2i << 8)  | (M2i >>> 24)) & 0x00ff00ff) |
 11695  	                    (((M2i << 24) | (M2i >>> 8))  & 0xff00ff00)
 11696  	                );
 11697  	                M2i1 = (
 11698  	                    (((M2i1 << 8)  | (M2i1 >>> 24)) & 0x00ff00ff) |
 11699  	                    (((M2i1 << 24) | (M2i1 >>> 8))  & 0xff00ff00)
 11700  	                );
 11701  
 11702  	                // Absorb message into state
 11703  	                var lane = state[i];
 11704  	                lane.high ^= M2i1;
 11705  	                lane.low  ^= M2i;
 11706  	            }
 11707  
 11708  	            // Rounds
 11709  	            for (var round = 0; round < 24; round++) {
 11710  	                // Theta
 11711  	                for (var x = 0; x < 5; x++) {
 11712  	                    // Mix column lanes
 11713  	                    var tMsw = 0, tLsw = 0;
 11714  	                    for (var y = 0; y < 5; y++) {
 11715  	                        var lane = state[x + 5 * y];
 11716  	                        tMsw ^= lane.high;
 11717  	                        tLsw ^= lane.low;
 11718  	                    }
 11719  
 11720  	                    // Temporary values
 11721  	                    var Tx = T[x];
 11722  	                    Tx.high = tMsw;
 11723  	                    Tx.low  = tLsw;
 11724  	                }
 11725  	                for (var x = 0; x < 5; x++) {
 11726  	                    // Shortcuts
 11727  	                    var Tx4 = T[(x + 4) % 5];
 11728  	                    var Tx1 = T[(x + 1) % 5];
 11729  	                    var Tx1Msw = Tx1.high;
 11730  	                    var Tx1Lsw = Tx1.low;
 11731  
 11732  	                    // Mix surrounding columns
 11733  	                    var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));
 11734  	                    var tLsw = Tx4.low  ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));
 11735  	                    for (var y = 0; y < 5; y++) {
 11736  	                        var lane = state[x + 5 * y];
 11737  	                        lane.high ^= tMsw;
 11738  	                        lane.low  ^= tLsw;
 11739  	                    }
 11740  	                }
 11741  
 11742  	                // Rho Pi
 11743  	                for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
 11744  	                    // Shortcuts
 11745  	                    var lane = state[laneIndex];
 11746  	                    var laneMsw = lane.high;
 11747  	                    var laneLsw = lane.low;
 11748  	                    var rhoOffset = RHO_OFFSETS[laneIndex];
 11749  
 11750  	                    // Rotate lanes
 11751  	                    if (rhoOffset < 32) {
 11752  	                        var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));
 11753  	                        var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));
 11754  	                    } else /* if (rhoOffset >= 32) */ {
 11755  	                        var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));
 11756  	                        var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));
 11757  	                    }
 11758  
 11759  	                    // Transpose lanes
 11760  	                    var TPiLane = T[PI_INDEXES[laneIndex]];
 11761  	                    TPiLane.high = tMsw;
 11762  	                    TPiLane.low  = tLsw;
 11763  	                }
 11764  
 11765  	                // Rho pi at x = y = 0
 11766  	                var T0 = T[0];
 11767  	                var state0 = state[0];
 11768  	                T0.high = state0.high;
 11769  	                T0.low  = state0.low;
 11770  
 11771  	                // Chi
 11772  	                for (var x = 0; x < 5; x++) {
 11773  	                    for (var y = 0; y < 5; y++) {
 11774  	                        // Shortcuts
 11775  	                        var laneIndex = x + 5 * y;
 11776  	                        var lane = state[laneIndex];
 11777  	                        var TLane = T[laneIndex];
 11778  	                        var Tx1Lane = T[((x + 1) % 5) + 5 * y];
 11779  	                        var Tx2Lane = T[((x + 2) % 5) + 5 * y];
 11780  
 11781  	                        // Mix rows
 11782  	                        lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);
 11783  	                        lane.low  = TLane.low  ^ (~Tx1Lane.low  & Tx2Lane.low);
 11784  	                    }
 11785  	                }
 11786  
 11787  	                // Iota
 11788  	                var lane = state[0];
 11789  	                var roundConstant = ROUND_CONSTANTS[round];
 11790  	                lane.high ^= roundConstant.high;
 11791  	                lane.low  ^= roundConstant.low;;
 11792  	            }
 11793  	        },
 11794  
 11795  	        _doFinalize: function () {
 11796  	            // Shortcuts
 11797  	            var data = this._data;
 11798  	            var dataWords = data.words;
 11799  	            var nBitsTotal = this._nDataBytes * 8;
 11800  	            var nBitsLeft = data.sigBytes * 8;
 11801  	            var blockSizeBits = this.blockSize * 32;
 11802  
 11803  	            // Add padding
 11804  	            dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);
 11805  	            dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;
 11806  	            data.sigBytes = dataWords.length * 4;
 11807  
 11808  	            // Hash final blocks
 11809  	            this._process();
 11810  
 11811  	            // Shortcuts
 11812  	            var state = this._state;
 11813  	            var outputLengthBytes = this.cfg.outputLength / 8;
 11814  	            var outputLengthLanes = outputLengthBytes / 8;
 11815  
 11816  	            // Squeeze
 11817  	            var hashWords = [];
 11818  	            for (var i = 0; i < outputLengthLanes; i++) {
 11819  	                // Shortcuts
 11820  	                var lane = state[i];
 11821  	                var laneMsw = lane.high;
 11822  	                var laneLsw = lane.low;
 11823  
 11824  	                // Swap endian
 11825  	                laneMsw = (
 11826  	                    (((laneMsw << 8)  | (laneMsw >>> 24)) & 0x00ff00ff) |
 11827  	                    (((laneMsw << 24) | (laneMsw >>> 8))  & 0xff00ff00)
 11828  	                );
 11829  	                laneLsw = (
 11830  	                    (((laneLsw << 8)  | (laneLsw >>> 24)) & 0x00ff00ff) |
 11831  	                    (((laneLsw << 24) | (laneLsw >>> 8))  & 0xff00ff00)
 11832  	                );
 11833  
 11834  	                // Squeeze state to retrieve hash
 11835  	                hashWords.push(laneLsw);
 11836  	                hashWords.push(laneMsw);
 11837  	            }
 11838  
 11839  	            // Return final computed hash
 11840  	            return new WordArray.init(hashWords, outputLengthBytes);
 11841  	        },
 11842  
 11843  	        clone: function () {
 11844  	            var clone = Hasher.clone.call(this);
 11845  
 11846  	            var state = clone._state = this._state.slice(0);
 11847  	            for (var i = 0; i < 25; i++) {
 11848  	                state[i] = state[i].clone();
 11849  	            }
 11850  
 11851  	            return clone;
 11852  	        }
 11853  	    });
 11854  
 11855  	    /**
 11856  	     * Shortcut function to the hasher's object interface.
 11857  	     *
 11858  	     * @param {WordArray|string} message The message to hash.
 11859  	     *
 11860  	     * @return {WordArray} The hash.
 11861  	     *
 11862  	     * @static
 11863  	     *
 11864  	     * @example
 11865  	     *
 11866  	     *     var hash = CryptoJS.SHA3('message');
 11867  	     *     var hash = CryptoJS.SHA3(wordArray);
 11868  	     */
 11869  	    C.SHA3 = Hasher._createHelper(SHA3);
 11870  
 11871  	    /**
 11872  	     * Shortcut function to the HMAC's object interface.
 11873  	     *
 11874  	     * @param {WordArray|string} message The message to hash.
 11875  	     * @param {WordArray|string} key The secret key.
 11876  	     *
 11877  	     * @return {WordArray} The HMAC.
 11878  	     *
 11879  	     * @static
 11880  	     *
 11881  	     * @example
 11882  	     *
 11883  	     *     var hmac = CryptoJS.HmacSHA3(message, key);
 11884  	     */
 11885  	    C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
 11886  	}(Math));
 11887  
 11888  
 11889  	return CryptoJS.SHA3;
 11890  
 11891  }));
 11892  },{"./core":53,"./x64-core":84}],81:[function(require,module,exports){
 11893  ;(function (root, factory, undef) {
 11894  	if (typeof exports === "object") {
 11895  		// CommonJS
 11896  		module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"));
 11897  	}
 11898  	else if (typeof define === "function" && define.amd) {
 11899  		// AMD
 11900  		define(["./core", "./x64-core", "./sha512"], factory);
 11901  	}
 11902  	else {
 11903  		// Global (browser)
 11904  		factory(root.CryptoJS);
 11905  	}
 11906  }(this, function (CryptoJS) {
 11907  
 11908  	(function () {
 11909  	    // Shortcuts
 11910  	    var C = CryptoJS;
 11911  	    var C_x64 = C.x64;
 11912  	    var X64Word = C_x64.Word;
 11913  	    var X64WordArray = C_x64.WordArray;
 11914  	    var C_algo = C.algo;
 11915  	    var SHA512 = C_algo.SHA512;
 11916  
 11917  	    /**
 11918  	     * SHA-384 hash algorithm.
 11919  	     */
 11920  	    var SHA384 = C_algo.SHA384 = SHA512.extend({
 11921  	        _doReset: function () {
 11922  	            this._hash = new X64WordArray.init([
 11923  	                new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507),
 11924  	                new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939),
 11925  	                new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511),
 11926  	                new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4)
 11927  	            ]);
 11928  	        },
 11929  
 11930  	        _doFinalize: function () {
 11931  	            var hash = SHA512._doFinalize.call(this);
 11932  
 11933  	            hash.sigBytes -= 16;
 11934  
 11935  	            return hash;
 11936  	        }
 11937  	    });
 11938  
 11939  	    /**
 11940  	     * Shortcut function to the hasher's object interface.
 11941  	     *
 11942  	     * @param {WordArray|string} message The message to hash.
 11943  	     *
 11944  	     * @return {WordArray} The hash.
 11945  	     *
 11946  	     * @static
 11947  	     *
 11948  	     * @example
 11949  	     *
 11950  	     *     var hash = CryptoJS.SHA384('message');
 11951  	     *     var hash = CryptoJS.SHA384(wordArray);
 11952  	     */
 11953  	    C.SHA384 = SHA512._createHelper(SHA384);
 11954  
 11955  	    /**
 11956  	     * Shortcut function to the HMAC's object interface.
 11957  	     *
 11958  	     * @param {WordArray|string} message The message to hash.
 11959  	     * @param {WordArray|string} key The secret key.
 11960  	     *
 11961  	     * @return {WordArray} The HMAC.
 11962  	     *
 11963  	     * @static
 11964  	     *
 11965  	     * @example
 11966  	     *
 11967  	     *     var hmac = CryptoJS.HmacSHA384(message, key);
 11968  	     */
 11969  	    C.HmacSHA384 = SHA512._createHmacHelper(SHA384);
 11970  	}());
 11971  
 11972  
 11973  	return CryptoJS.SHA384;
 11974  
 11975  }));
 11976  },{"./core":53,"./sha512":82,"./x64-core":84}],82:[function(require,module,exports){
 11977  ;(function (root, factory, undef) {
 11978  	if (typeof exports === "object") {
 11979  		// CommonJS
 11980  		module.exports = exports = factory(require("./core"), require("./x64-core"));
 11981  	}
 11982  	else if (typeof define === "function" && define.amd) {
 11983  		// AMD
 11984  		define(["./core", "./x64-core"], factory);
 11985  	}
 11986  	else {
 11987  		// Global (browser)
 11988  		factory(root.CryptoJS);
 11989  	}
 11990  }(this, function (CryptoJS) {
 11991  
 11992  	(function () {
 11993  	    // Shortcuts
 11994  	    var C = CryptoJS;
 11995  	    var C_lib = C.lib;
 11996  	    var Hasher = C_lib.Hasher;
 11997  	    var C_x64 = C.x64;
 11998  	    var X64Word = C_x64.Word;
 11999  	    var X64WordArray = C_x64.WordArray;
 12000  	    var C_algo = C.algo;
 12001  
 12002  	    function X64Word_create() {
 12003  	        return X64Word.create.apply(X64Word, arguments);
 12004  	    }
 12005  
 12006  	    // Constants
 12007  	    var K = [
 12008  	        X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd),
 12009  	        X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc),
 12010  	        X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019),
 12011  	        X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118),
 12012  	        X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe),
 12013  	        X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2),
 12014  	        X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1),
 12015  	        X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694),
 12016  	        X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3),
 12017  	        X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65),
 12018  	        X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483),
 12019  	        X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5),
 12020  	        X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210),
 12021  	        X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4),
 12022  	        X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725),
 12023  	        X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70),
 12024  	        X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926),
 12025  	        X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df),
 12026  	        X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8),
 12027  	        X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b),
 12028  	        X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001),
 12029  	        X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30),
 12030  	        X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910),
 12031  	        X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8),
 12032  	        X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53),
 12033  	        X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8),
 12034  	        X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb),
 12035  	        X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3),
 12036  	        X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60),
 12037  	        X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec),
 12038  	        X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9),
 12039  	        X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b),
 12040  	        X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207),
 12041  	        X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178),
 12042  	        X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6),
 12043  	        X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b),
 12044  	        X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493),
 12045  	        X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c),
 12046  	        X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a),
 12047  	        X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817)
 12048  	    ];
 12049  
 12050  	    // Reusable objects
 12051  	    var W = [];
 12052  	    (function () {
 12053  	        for (var i = 0; i < 80; i++) {
 12054  	            W[i] = X64Word_create();
 12055  	        }
 12056  	    }());
 12057  
 12058  	    /**
 12059  	     * SHA-512 hash algorithm.
 12060  	     */
 12061  	    var SHA512 = C_algo.SHA512 = Hasher.extend({
 12062  	        _doReset: function () {
 12063  	            this._hash = new X64WordArray.init([
 12064  	                new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),
 12065  	                new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),
 12066  	                new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),
 12067  	                new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179)
 12068  	            ]);
 12069  	        },
 12070  
 12071  	        _doProcessBlock: function (M, offset) {
 12072  	            // Shortcuts
 12073  	            var H = this._hash.words;
 12074  
 12075  	            var H0 = H[0];
 12076  	            var H1 = H[1];
 12077  	            var H2 = H[2];
 12078  	            var H3 = H[3];
 12079  	            var H4 = H[4];
 12080  	            var H5 = H[5];
 12081  	            var H6 = H[6];
 12082  	            var H7 = H[7];
 12083  
 12084  	            var H0h = H0.high;
 12085  	            var H0l = H0.low;
 12086  	            var H1h = H1.high;
 12087  	            var H1l = H1.low;
 12088  	            var H2h = H2.high;
 12089  	            var H2l = H2.low;
 12090  	            var H3h = H3.high;
 12091  	            var H3l = H3.low;
 12092  	            var H4h = H4.high;
 12093  	            var H4l = H4.low;
 12094  	            var H5h = H5.high;
 12095  	            var H5l = H5.low;
 12096  	            var H6h = H6.high;
 12097  	            var H6l = H6.low;
 12098  	            var H7h = H7.high;
 12099  	            var H7l = H7.low;
 12100  
 12101  	            // Working variables
 12102  	            var ah = H0h;
 12103  	            var al = H0l;
 12104  	            var bh = H1h;
 12105  	            var bl = H1l;
 12106  	            var ch = H2h;
 12107  	            var cl = H2l;
 12108  	            var dh = H3h;
 12109  	            var dl = H3l;
 12110  	            var eh = H4h;
 12111  	            var el = H4l;
 12112  	            var fh = H5h;
 12113  	            var fl = H5l;
 12114  	            var gh = H6h;
 12115  	            var gl = H6l;
 12116  	            var hh = H7h;
 12117  	            var hl = H7l;
 12118  
 12119  	            // Rounds
 12120  	            for (var i = 0; i < 80; i++) {
 12121  	                // Shortcut
 12122  	                var Wi = W[i];
 12123  
 12124  	                // Extend message
 12125  	                if (i < 16) {
 12126  	                    var Wih = Wi.high = M[offset + i * 2]     | 0;
 12127  	                    var Wil = Wi.low  = M[offset + i * 2 + 1] | 0;
 12128  	                } else {
 12129  	                    // Gamma0
 12130  	                    var gamma0x  = W[i - 15];
 12131  	                    var gamma0xh = gamma0x.high;
 12132  	                    var gamma0xl = gamma0x.low;
 12133  	                    var gamma0h  = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7);
 12134  	                    var gamma0l  = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));
 12135  
 12136  	                    // Gamma1
 12137  	                    var gamma1x  = W[i - 2];
 12138  	                    var gamma1xh = gamma1x.high;
 12139  	                    var gamma1xl = gamma1x.low;
 12140  	                    var gamma1h  = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6);
 12141  	                    var gamma1l  = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));
 12142  
 12143  	                    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
 12144  	                    var Wi7  = W[i - 7];
 12145  	                    var Wi7h = Wi7.high;
 12146  	                    var Wi7l = Wi7.low;
 12147  
 12148  	                    var Wi16  = W[i - 16];
 12149  	                    var Wi16h = Wi16.high;
 12150  	                    var Wi16l = Wi16.low;
 12151  
 12152  	                    var Wil = gamma0l + Wi7l;
 12153  	                    var Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);
 12154  	                    var Wil = Wil + gamma1l;
 12155  	                    var Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);
 12156  	                    var Wil = Wil + Wi16l;
 12157  	                    var Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);
 12158  
 12159  	                    Wi.high = Wih;
 12160  	                    Wi.low  = Wil;
 12161  	                }
 12162  
 12163  	                var chh  = (eh & fh) ^ (~eh & gh);
 12164  	                var chl  = (el & fl) ^ (~el & gl);
 12165  	                var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
 12166  	                var majl = (al & bl) ^ (al & cl) ^ (bl & cl);
 12167  
 12168  	                var sigma0h = ((ah >>> 28) | (al << 4))  ^ ((ah << 30)  | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
 12169  	                var sigma0l = ((al >>> 28) | (ah << 4))  ^ ((al << 30)  | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
 12170  	                var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));
 12171  	                var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));
 12172  
 12173  	                // t1 = h + sigma1 + ch + K[i] + W[i]
 12174  	                var Ki  = K[i];
 12175  	                var Kih = Ki.high;
 12176  	                var Kil = Ki.low;
 12177  
 12178  	                var t1l = hl + sigma1l;
 12179  	                var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);
 12180  	                var t1l = t1l + chl;
 12181  	                var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
 12182  	                var t1l = t1l + Kil;
 12183  	                var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);
 12184  	                var t1l = t1l + Wil;
 12185  	                var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);
 12186  
 12187  	                // t2 = sigma0 + maj
 12188  	                var t2l = sigma0l + majl;
 12189  	                var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);
 12190  
 12191  	                // Update working variables
 12192  	                hh = gh;
 12193  	                hl = gl;
 12194  	                gh = fh;
 12195  	                gl = fl;
 12196  	                fh = eh;
 12197  	                fl = el;
 12198  	                el = (dl + t1l) | 0;
 12199  	                eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
 12200  	                dh = ch;
 12201  	                dl = cl;
 12202  	                ch = bh;
 12203  	                cl = bl;
 12204  	                bh = ah;
 12205  	                bl = al;
 12206  	                al = (t1l + t2l) | 0;
 12207  	                ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;
 12208  	            }
 12209  
 12210  	            // Intermediate hash value
 12211  	            H0l = H0.low  = (H0l + al);
 12212  	            H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));
 12213  	            H1l = H1.low  = (H1l + bl);
 12214  	            H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));
 12215  	            H2l = H2.low  = (H2l + cl);
 12216  	            H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));
 12217  	            H3l = H3.low  = (H3l + dl);
 12218  	            H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));
 12219  	            H4l = H4.low  = (H4l + el);
 12220  	            H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));
 12221  	            H5l = H5.low  = (H5l + fl);
 12222  	            H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));
 12223  	            H6l = H6.low  = (H6l + gl);
 12224  	            H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));
 12225  	            H7l = H7.low  = (H7l + hl);
 12226  	            H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));
 12227  	        },
 12228  
 12229  	        _doFinalize: function () {
 12230  	            // Shortcuts
 12231  	            var data = this._data;
 12232  	            var dataWords = data.words;
 12233  
 12234  	            var nBitsTotal = this._nDataBytes * 8;
 12235  	            var nBitsLeft = data.sigBytes * 8;
 12236  
 12237  	            // Add padding
 12238  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
 12239  	            dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);
 12240  	            dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;
 12241  	            data.sigBytes = dataWords.length * 4;
 12242  
 12243  	            // Hash final blocks
 12244  	            this._process();
 12245  
 12246  	            // Convert hash to 32-bit word array before returning
 12247  	            var hash = this._hash.toX32();
 12248  
 12249  	            // Return final computed hash
 12250  	            return hash;
 12251  	        },
 12252  
 12253  	        clone: function () {
 12254  	            var clone = Hasher.clone.call(this);
 12255  	            clone._hash = this._hash.clone();
 12256  
 12257  	            return clone;
 12258  	        },
 12259  
 12260  	        blockSize: 1024/32
 12261  	    });
 12262  
 12263  	    /**
 12264  	     * Shortcut function to the hasher's object interface.
 12265  	     *
 12266  	     * @param {WordArray|string} message The message to hash.
 12267  	     *
 12268  	     * @return {WordArray} The hash.
 12269  	     *
 12270  	     * @static
 12271  	     *
 12272  	     * @example
 12273  	     *
 12274  	     *     var hash = CryptoJS.SHA512('message');
 12275  	     *     var hash = CryptoJS.SHA512(wordArray);
 12276  	     */
 12277  	    C.SHA512 = Hasher._createHelper(SHA512);
 12278  
 12279  	    /**
 12280  	     * Shortcut function to the HMAC's object interface.
 12281  	     *
 12282  	     * @param {WordArray|string} message The message to hash.
 12283  	     * @param {WordArray|string} key The secret key.
 12284  	     *
 12285  	     * @return {WordArray} The HMAC.
 12286  	     *
 12287  	     * @static
 12288  	     *
 12289  	     * @example
 12290  	     *
 12291  	     *     var hmac = CryptoJS.HmacSHA512(message, key);
 12292  	     */
 12293  	    C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
 12294  	}());
 12295  
 12296  
 12297  	return CryptoJS.SHA512;
 12298  
 12299  }));
 12300  },{"./core":53,"./x64-core":84}],83:[function(require,module,exports){
 12301  ;(function (root, factory, undef) {
 12302  	if (typeof exports === "object") {
 12303  		// CommonJS
 12304  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
 12305  	}
 12306  	else if (typeof define === "function" && define.amd) {
 12307  		// AMD
 12308  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
 12309  	}
 12310  	else {
 12311  		// Global (browser)
 12312  		factory(root.CryptoJS);
 12313  	}
 12314  }(this, function (CryptoJS) {
 12315  
 12316  	(function () {
 12317  	    // Shortcuts
 12318  	    var C = CryptoJS;
 12319  	    var C_lib = C.lib;
 12320  	    var WordArray = C_lib.WordArray;
 12321  	    var BlockCipher = C_lib.BlockCipher;
 12322  	    var C_algo = C.algo;
 12323  
 12324  	    // Permuted Choice 1 constants
 12325  	    var PC1 = [
 12326  	        57, 49, 41, 33, 25, 17, 9,  1,
 12327  	        58, 50, 42, 34, 26, 18, 10, 2,
 12328  	        59, 51, 43, 35, 27, 19, 11, 3,
 12329  	        60, 52, 44, 36, 63, 55, 47, 39,
 12330  	        31, 23, 15, 7,  62, 54, 46, 38,
 12331  	        30, 22, 14, 6,  61, 53, 45, 37,
 12332  	        29, 21, 13, 5,  28, 20, 12, 4
 12333  	    ];
 12334  
 12335  	    // Permuted Choice 2 constants
 12336  	    var PC2 = [
 12337  	        14, 17, 11, 24, 1,  5,
 12338  	        3,  28, 15, 6,  21, 10,
 12339  	        23, 19, 12, 4,  26, 8,
 12340  	        16, 7,  27, 20, 13, 2,
 12341  	        41, 52, 31, 37, 47, 55,
 12342  	        30, 40, 51, 45, 33, 48,
 12343  	        44, 49, 39, 56, 34, 53,
 12344  	        46, 42, 50, 36, 29, 32
 12345  	    ];
 12346  
 12347  	    // Cumulative bit shift constants
 12348  	    var BIT_SHIFTS = [1,  2,  4,  6,  8,  10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
 12349  
 12350  	    // SBOXes and round permutation constants
 12351  	    var SBOX_P = [
 12352  	        {
 12353  	            0x0: 0x808200,
 12354  	            0x10000000: 0x8000,
 12355  	            0x20000000: 0x808002,
 12356  	            0x30000000: 0x2,
 12357  	            0x40000000: 0x200,
 12358  	            0x50000000: 0x808202,
 12359  	            0x60000000: 0x800202,
 12360  	            0x70000000: 0x800000,
 12361  	            0x80000000: 0x202,
 12362  	            0x90000000: 0x800200,
 12363  	            0xa0000000: 0x8200,
 12364  	            0xb0000000: 0x808000,
 12365  	            0xc0000000: 0x8002,
 12366  	            0xd0000000: 0x800002,
 12367  	            0xe0000000: 0x0,
 12368  	            0xf0000000: 0x8202,
 12369  	            0x8000000: 0x0,
 12370  	            0x18000000: 0x808202,
 12371  	            0x28000000: 0x8202,
 12372  	            0x38000000: 0x8000,
 12373  	            0x48000000: 0x808200,
 12374  	            0x58000000: 0x200,
 12375  	            0x68000000: 0x808002,
 12376  	            0x78000000: 0x2,
 12377  	            0x88000000: 0x800200,
 12378  	            0x98000000: 0x8200,
 12379  	            0xa8000000: 0x808000,
 12380  	            0xb8000000: 0x800202,
 12381  	            0xc8000000: 0x800002,
 12382  	            0xd8000000: 0x8002,
 12383  	            0xe8000000: 0x202,
 12384  	            0xf8000000: 0x800000,
 12385  	            0x1: 0x8000,
 12386  	            0x10000001: 0x2,
 12387  	            0x20000001: 0x808200,
 12388  	            0x30000001: 0x800000,
 12389  	            0x40000001: 0x808002,
 12390  	            0x50000001: 0x8200,
 12391  	            0x60000001: 0x200,
 12392  	            0x70000001: 0x800202,
 12393  	            0x80000001: 0x808202,
 12394  	            0x90000001: 0x808000,
 12395  	            0xa0000001: 0x800002,
 12396  	            0xb0000001: 0x8202,
 12397  	            0xc0000001: 0x202,
 12398  	            0xd0000001: 0x800200,
 12399  	            0xe0000001: 0x8002,
 12400  	            0xf0000001: 0x0,
 12401  	            0x8000001: 0x808202,
 12402  	            0x18000001: 0x808000,
 12403  	            0x28000001: 0x800000,
 12404  	            0x38000001: 0x200,
 12405  	            0x48000001: 0x8000,
 12406  	            0x58000001: 0x800002,
 12407  	            0x68000001: 0x2,
 12408  	            0x78000001: 0x8202,
 12409  	            0x88000001: 0x8002,
 12410  	            0x98000001: 0x800202,
 12411  	            0xa8000001: 0x202,
 12412  	            0xb8000001: 0x808200,
 12413  	            0xc8000001: 0x800200,
 12414  	            0xd8000001: 0x0,
 12415  	            0xe8000001: 0x8200,
 12416  	            0xf8000001: 0x808002
 12417  	        },
 12418  	        {
 12419  	            0x0: 0x40084010,
 12420  	            0x1000000: 0x4000,
 12421  	            0x2000000: 0x80000,
 12422  	            0x3000000: 0x40080010,
 12423  	            0x4000000: 0x40000010,
 12424  	            0x5000000: 0x40084000,
 12425  	            0x6000000: 0x40004000,
 12426  	            0x7000000: 0x10,
 12427  	            0x8000000: 0x84000,
 12428  	            0x9000000: 0x40004010,
 12429  	            0xa000000: 0x40000000,
 12430  	            0xb000000: 0x84010,
 12431  	            0xc000000: 0x80010,
 12432  	            0xd000000: 0x0,
 12433  	            0xe000000: 0x4010,
 12434  	            0xf000000: 0x40080000,
 12435  	            0x800000: 0x40004000,
 12436  	            0x1800000: 0x84010,
 12437  	            0x2800000: 0x10,
 12438  	            0x3800000: 0x40004010,
 12439  	            0x4800000: 0x40084010,
 12440  	            0x5800000: 0x40000000,
 12441  	            0x6800000: 0x80000,
 12442  	            0x7800000: 0x40080010,
 12443  	            0x8800000: 0x80010,
 12444  	            0x9800000: 0x0,
 12445  	            0xa800000: 0x4000,
 12446  	            0xb800000: 0x40080000,
 12447  	            0xc800000: 0x40000010,
 12448  	            0xd800000: 0x84000,
 12449  	            0xe800000: 0x40084000,
 12450  	            0xf800000: 0x4010,
 12451  	            0x10000000: 0x0,
 12452  	            0x11000000: 0x40080010,
 12453  	            0x12000000: 0x40004010,
 12454  	            0x13000000: 0x40084000,
 12455  	            0x14000000: 0x40080000,
 12456  	            0x15000000: 0x10,
 12457  	            0x16000000: 0x84010,
 12458  	            0x17000000: 0x4000,
 12459  	            0x18000000: 0x4010,
 12460  	            0x19000000: 0x80000,
 12461  	            0x1a000000: 0x80010,
 12462  	            0x1b000000: 0x40000010,
 12463  	            0x1c000000: 0x84000,
 12464  	            0x1d000000: 0x40004000,
 12465  	            0x1e000000: 0x40000000,
 12466  	            0x1f000000: 0x40084010,
 12467  	            0x10800000: 0x84010,
 12468  	            0x11800000: 0x80000,
 12469  	            0x12800000: 0x40080000,
 12470  	            0x13800000: 0x4000,
 12471  	            0x14800000: 0x40004000,
 12472  	            0x15800000: 0x40084010,
 12473  	            0x16800000: 0x10,
 12474  	            0x17800000: 0x40000000,
 12475  	            0x18800000: 0x40084000,
 12476  	            0x19800000: 0x40000010,
 12477  	            0x1a800000: 0x40004010,
 12478  	            0x1b800000: 0x80010,
 12479  	            0x1c800000: 0x0,
 12480  	            0x1d800000: 0x4010,
 12481  	            0x1e800000: 0x40080010,
 12482  	            0x1f800000: 0x84000
 12483  	        },
 12484  	        {
 12485  	            0x0: 0x104,
 12486  	            0x100000: 0x0,
 12487  	            0x200000: 0x4000100,
 12488  	            0x300000: 0x10104,
 12489  	            0x400000: 0x10004,
 12490  	            0x500000: 0x4000004,
 12491  	            0x600000: 0x4010104,
 12492  	            0x700000: 0x4010000,
 12493  	            0x800000: 0x4000000,
 12494  	            0x900000: 0x4010100,
 12495  	            0xa00000: 0x10100,
 12496  	            0xb00000: 0x4010004,
 12497  	            0xc00000: 0x4000104,
 12498  	            0xd00000: 0x10000,
 12499  	            0xe00000: 0x4,
 12500  	            0xf00000: 0x100,
 12501  	            0x80000: 0x4010100,
 12502  	            0x180000: 0x4010004,
 12503  	            0x280000: 0x0,
 12504  	            0x380000: 0x4000100,
 12505  	            0x480000: 0x4000004,
 12506  	            0x580000: 0x10000,
 12507  	            0x680000: 0x10004,
 12508  	            0x780000: 0x104,
 12509  	            0x880000: 0x4,
 12510  	            0x980000: 0x100,
 12511  	            0xa80000: 0x4010000,
 12512  	            0xb80000: 0x10104,
 12513  	            0xc80000: 0x10100,
 12514  	            0xd80000: 0x4000104,
 12515  	            0xe80000: 0x4010104,
 12516  	            0xf80000: 0x4000000,
 12517  	            0x1000000: 0x4010100,
 12518  	            0x1100000: 0x10004,
 12519  	            0x1200000: 0x10000,
 12520  	            0x1300000: 0x4000100,
 12521  	            0x1400000: 0x100,
 12522  	            0x1500000: 0x4010104,
 12523  	            0x1600000: 0x4000004,
 12524  	            0x1700000: 0x0,
 12525  	            0x1800000: 0x4000104,
 12526  	            0x1900000: 0x4000000,
 12527  	            0x1a00000: 0x4,
 12528  	            0x1b00000: 0x10100,
 12529  	            0x1c00000: 0x4010000,
 12530  	            0x1d00000: 0x104,
 12531  	            0x1e00000: 0x10104,
 12532  	            0x1f00000: 0x4010004,
 12533  	            0x1080000: 0x4000000,
 12534  	            0x1180000: 0x104,
 12535  	            0x1280000: 0x4010100,
 12536  	            0x1380000: 0x0,
 12537  	            0x1480000: 0x10004,
 12538  	            0x1580000: 0x4000100,
 12539  	            0x1680000: 0x100,
 12540  	            0x1780000: 0x4010004,
 12541  	            0x1880000: 0x10000,
 12542  	            0x1980000: 0x4010104,
 12543  	            0x1a80000: 0x10104,
 12544  	            0x1b80000: 0x4000004,
 12545  	            0x1c80000: 0x4000104,
 12546  	            0x1d80000: 0x4010000,
 12547  	            0x1e80000: 0x4,
 12548  	            0x1f80000: 0x10100
 12549  	        },
 12550  	        {
 12551  	            0x0: 0x80401000,
 12552  	            0x10000: 0x80001040,
 12553  	            0x20000: 0x401040,
 12554  	            0x30000: 0x80400000,
 12555  	            0x40000: 0x0,
 12556  	            0x50000: 0x401000,
 12557  	            0x60000: 0x80000040,
 12558  	            0x70000: 0x400040,
 12559  	            0x80000: 0x80000000,
 12560  	            0x90000: 0x400000,
 12561  	            0xa0000: 0x40,
 12562  	            0xb0000: 0x80001000,
 12563  	            0xc0000: 0x80400040,
 12564  	            0xd0000: 0x1040,
 12565  	            0xe0000: 0x1000,
 12566  	            0xf0000: 0x80401040,
 12567  	            0x8000: 0x80001040,
 12568  	            0x18000: 0x40,
 12569  	            0x28000: 0x80400040,
 12570  	            0x38000: 0x80001000,
 12571  	            0x48000: 0x401000,
 12572  	            0x58000: 0x80401040,
 12573  	            0x68000: 0x0,
 12574  	            0x78000: 0x80400000,
 12575  	            0x88000: 0x1000,
 12576  	            0x98000: 0x80401000,
 12577  	            0xa8000: 0x400000,
 12578  	            0xb8000: 0x1040,
 12579  	            0xc8000: 0x80000000,
 12580  	            0xd8000: 0x400040,
 12581  	            0xe8000: 0x401040,
 12582  	            0xf8000: 0x80000040,
 12583  	            0x100000: 0x400040,
 12584  	            0x110000: 0x401000,
 12585  	            0x120000: 0x80000040,
 12586  	            0x130000: 0x0,
 12587  	            0x140000: 0x1040,
 12588  	            0x150000: 0x80400040,
 12589  	            0x160000: 0x80401000,
 12590  	            0x170000: 0x80001040,
 12591  	            0x180000: 0x80401040,
 12592  	            0x190000: 0x80000000,
 12593  	            0x1a0000: 0x80400000,
 12594  	            0x1b0000: 0x401040,
 12595  	            0x1c0000: 0x80001000,
 12596  	            0x1d0000: 0x400000,
 12597  	            0x1e0000: 0x40,
 12598  	            0x1f0000: 0x1000,
 12599  	            0x108000: 0x80400000,
 12600  	            0x118000: 0x80401040,
 12601  	            0x128000: 0x0,
 12602  	            0x138000: 0x401000,
 12603  	            0x148000: 0x400040,
 12604  	            0x158000: 0x80000000,
 12605  	            0x168000: 0x80001040,
 12606  	            0x178000: 0x40,
 12607  	            0x188000: 0x80000040,
 12608  	            0x198000: 0x1000,
 12609  	            0x1a8000: 0x80001000,
 12610  	            0x1b8000: 0x80400040,
 12611  	            0x1c8000: 0x1040,
 12612  	            0x1d8000: 0x80401000,
 12613  	            0x1e8000: 0x400000,
 12614  	            0x1f8000: 0x401040
 12615  	        },
 12616  	        {
 12617  	            0x0: 0x80,
 12618  	            0x1000: 0x1040000,
 12619  	            0x2000: 0x40000,
 12620  	            0x3000: 0x20000000,
 12621  	            0x4000: 0x20040080,
 12622  	            0x5000: 0x1000080,
 12623  	            0x6000: 0x21000080,
 12624  	            0x7000: 0x40080,
 12625  	            0x8000: 0x1000000,
 12626  	            0x9000: 0x20040000,
 12627  	            0xa000: 0x20000080,
 12628  	            0xb000: 0x21040080,
 12629  	            0xc000: 0x21040000,
 12630  	            0xd000: 0x0,
 12631  	            0xe000: 0x1040080,
 12632  	            0xf000: 0x21000000,
 12633  	            0x800: 0x1040080,
 12634  	            0x1800: 0x21000080,
 12635  	            0x2800: 0x80,
 12636  	            0x3800: 0x1040000,
 12637  	            0x4800: 0x40000,
 12638  	            0x5800: 0x20040080,
 12639  	            0x6800: 0x21040000,
 12640  	            0x7800: 0x20000000,
 12641  	            0x8800: 0x20040000,
 12642  	            0x9800: 0x0,
 12643  	            0xa800: 0x21040080,
 12644  	            0xb800: 0x1000080,
 12645  	            0xc800: 0x20000080,
 12646  	            0xd800: 0x21000000,
 12647  	            0xe800: 0x1000000,
 12648  	            0xf800: 0x40080,
 12649  	            0x10000: 0x40000,
 12650  	            0x11000: 0x80,
 12651  	            0x12000: 0x20000000,
 12652  	            0x13000: 0x21000080,
 12653  	            0x14000: 0x1000080,
 12654  	            0x15000: 0x21040000,
 12655  	            0x16000: 0x20040080,
 12656  	            0x17000: 0x1000000,
 12657  	            0x18000: 0x21040080,
 12658  	            0x19000: 0x21000000,
 12659  	            0x1a000: 0x1040000,
 12660  	            0x1b000: 0x20040000,
 12661  	            0x1c000: 0x40080,
 12662  	            0x1d000: 0x20000080,
 12663  	            0x1e000: 0x0,
 12664  	            0x1f000: 0x1040080,
 12665  	            0x10800: 0x21000080,
 12666  	            0x11800: 0x1000000,
 12667  	            0x12800: 0x1040000,
 12668  	            0x13800: 0x20040080,
 12669  	            0x14800: 0x20000000,
 12670  	            0x15800: 0x1040080,
 12671  	            0x16800: 0x80,
 12672  	            0x17800: 0x21040000,
 12673  	            0x18800: 0x40080,
 12674  	            0x19800: 0x21040080,
 12675  	            0x1a800: 0x0,
 12676  	            0x1b800: 0x21000000,
 12677  	            0x1c800: 0x1000080,
 12678  	            0x1d800: 0x40000,
 12679  	            0x1e800: 0x20040000,
 12680  	            0x1f800: 0x20000080
 12681  	        },
 12682  	        {
 12683  	            0x0: 0x10000008,
 12684  	            0x100: 0x2000,
 12685  	            0x200: 0x10200000,
 12686  	            0x300: 0x10202008,
 12687  	            0x400: 0x10002000,
 12688  	            0x500: 0x200000,
 12689  	            0x600: 0x200008,
 12690  	            0x700: 0x10000000,
 12691  	            0x800: 0x0,
 12692  	            0x900: 0x10002008,
 12693  	            0xa00: 0x202000,
 12694  	            0xb00: 0x8,
 12695  	            0xc00: 0x10200008,
 12696  	            0xd00: 0x202008,
 12697  	            0xe00: 0x2008,
 12698  	            0xf00: 0x10202000,
 12699  	            0x80: 0x10200000,
 12700  	            0x180: 0x10202008,
 12701  	            0x280: 0x8,
 12702  	            0x380: 0x200000,
 12703  	            0x480: 0x202008,
 12704  	            0x580: 0x10000008,
 12705  	            0x680: 0x10002000,
 12706  	            0x780: 0x2008,
 12707  	            0x880: 0x200008,
 12708  	            0x980: 0x2000,
 12709  	            0xa80: 0x10002008,
 12710  	            0xb80: 0x10200008,
 12711  	            0xc80: 0x0,
 12712  	            0xd80: 0x10202000,
 12713  	            0xe80: 0x202000,
 12714  	            0xf80: 0x10000000,
 12715  	            0x1000: 0x10002000,
 12716  	            0x1100: 0x10200008,
 12717  	            0x1200: 0x10202008,
 12718  	            0x1300: 0x2008,
 12719  	            0x1400: 0x200000,
 12720  	            0x1500: 0x10000000,
 12721  	            0x1600: 0x10000008,
 12722  	            0x1700: 0x202000,
 12723  	            0x1800: 0x202008,
 12724  	            0x1900: 0x0,
 12725  	            0x1a00: 0x8,
 12726  	            0x1b00: 0x10200000,
 12727  	            0x1c00: 0x2000,
 12728  	            0x1d00: 0x10002008,
 12729  	            0x1e00: 0x10202000,
 12730  	            0x1f00: 0x200008,
 12731  	            0x1080: 0x8,
 12732  	            0x1180: 0x202000,
 12733  	            0x1280: 0x200000,
 12734  	            0x1380: 0x10000008,
 12735  	            0x1480: 0x10002000,
 12736  	            0x1580: 0x2008,
 12737  	            0x1680: 0x10202008,
 12738  	            0x1780: 0x10200000,
 12739  	            0x1880: 0x10202000,
 12740  	            0x1980: 0x10200008,
 12741  	            0x1a80: 0x2000,
 12742  	            0x1b80: 0x202008,
 12743  	            0x1c80: 0x200008,
 12744  	            0x1d80: 0x0,
 12745  	            0x1e80: 0x10000000,
 12746  	            0x1f80: 0x10002008
 12747  	        },
 12748  	        {
 12749  	            0x0: 0x100000,
 12750  	            0x10: 0x2000401,
 12751  	            0x20: 0x400,
 12752  	            0x30: 0x100401,
 12753  	            0x40: 0x2100401,
 12754  	            0x50: 0x0,
 12755  	            0x60: 0x1,
 12756  	            0x70: 0x2100001,
 12757  	            0x80: 0x2000400,
 12758  	            0x90: 0x100001,
 12759  	            0xa0: 0x2000001,
 12760  	            0xb0: 0x2100400,
 12761  	            0xc0: 0x2100000,
 12762  	            0xd0: 0x401,
 12763  	            0xe0: 0x100400,
 12764  	            0xf0: 0x2000000,
 12765  	            0x8: 0x2100001,
 12766  	            0x18: 0x0,
 12767  	            0x28: 0x2000401,
 12768  	            0x38: 0x2100400,
 12769  	            0x48: 0x100000,
 12770  	            0x58: 0x2000001,
 12771  	            0x68: 0x2000000,
 12772  	            0x78: 0x401,
 12773  	            0x88: 0x100401,
 12774  	            0x98: 0x2000400,
 12775  	            0xa8: 0x2100000,
 12776  	            0xb8: 0x100001,
 12777  	            0xc8: 0x400,
 12778  	            0xd8: 0x2100401,
 12779  	            0xe8: 0x1,
 12780  	            0xf8: 0x100400,
 12781  	            0x100: 0x2000000,
 12782  	            0x110: 0x100000,
 12783  	            0x120: 0x2000401,
 12784  	            0x130: 0x2100001,
 12785  	            0x140: 0x100001,
 12786  	            0x150: 0x2000400,
 12787  	            0x160: 0x2100400,
 12788  	            0x170: 0x100401,
 12789  	            0x180: 0x401,
 12790  	            0x190: 0x2100401,
 12791  	            0x1a0: 0x100400,
 12792  	            0x1b0: 0x1,
 12793  	            0x1c0: 0x0,
 12794  	            0x1d0: 0x2100000,
 12795  	            0x1e0: 0x2000001,
 12796  	            0x1f0: 0x400,
 12797  	            0x108: 0x100400,
 12798  	            0x118: 0x2000401,
 12799  	            0x128: 0x2100001,
 12800  	            0x138: 0x1,
 12801  	            0x148: 0x2000000,
 12802  	            0x158: 0x100000,
 12803  	            0x168: 0x401,
 12804  	            0x178: 0x2100400,
 12805  	            0x188: 0x2000001,
 12806  	            0x198: 0x2100000,
 12807  	            0x1a8: 0x0,
 12808  	            0x1b8: 0x2100401,
 12809  	            0x1c8: 0x100401,
 12810  	            0x1d8: 0x400,
 12811  	            0x1e8: 0x2000400,
 12812  	            0x1f8: 0x100001
 12813  	        },
 12814  	        {
 12815  	            0x0: 0x8000820,
 12816  	            0x1: 0x20000,
 12817  	            0x2: 0x8000000,
 12818  	            0x3: 0x20,
 12819  	            0x4: 0x20020,
 12820  	            0x5: 0x8020820,
 12821  	            0x6: 0x8020800,
 12822  	            0x7: 0x800,
 12823  	            0x8: 0x8020000,
 12824  	            0x9: 0x8000800,
 12825  	            0xa: 0x20800,
 12826  	            0xb: 0x8020020,
 12827  	            0xc: 0x820,
 12828  	            0xd: 0x0,
 12829  	            0xe: 0x8000020,
 12830  	            0xf: 0x20820,
 12831  	            0x80000000: 0x800,
 12832  	            0x80000001: 0x8020820,
 12833  	            0x80000002: 0x8000820,
 12834  	            0x80000003: 0x8000000,
 12835  	            0x80000004: 0x8020000,
 12836  	            0x80000005: 0x20800,
 12837  	            0x80000006: 0x20820,
 12838  	            0x80000007: 0x20,
 12839  	            0x80000008: 0x8000020,
 12840  	            0x80000009: 0x820,
 12841  	            0x8000000a: 0x20020,
 12842  	            0x8000000b: 0x8020800,
 12843  	            0x8000000c: 0x0,
 12844  	            0x8000000d: 0x8020020,
 12845  	            0x8000000e: 0x8000800,
 12846  	            0x8000000f: 0x20000,
 12847  	            0x10: 0x20820,
 12848  	            0x11: 0x8020800,
 12849  	            0x12: 0x20,
 12850  	            0x13: 0x800,
 12851  	            0x14: 0x8000800,
 12852  	            0x15: 0x8000020,
 12853  	            0x16: 0x8020020,
 12854  	            0x17: 0x20000,
 12855  	            0x18: 0x0,
 12856  	            0x19: 0x20020,
 12857  	            0x1a: 0x8020000,
 12858  	            0x1b: 0x8000820,
 12859  	            0x1c: 0x8020820,
 12860  	            0x1d: 0x20800,
 12861  	            0x1e: 0x820,
 12862  	            0x1f: 0x8000000,
 12863  	            0x80000010: 0x20000,
 12864  	            0x80000011: 0x800,
 12865  	            0x80000012: 0x8020020,
 12866  	            0x80000013: 0x20820,
 12867  	            0x80000014: 0x20,
 12868  	            0x80000015: 0x8020000,
 12869  	            0x80000016: 0x8000000,
 12870  	            0x80000017: 0x8000820,
 12871  	            0x80000018: 0x8020820,
 12872  	            0x80000019: 0x8000020,
 12873  	            0x8000001a: 0x8000800,
 12874  	            0x8000001b: 0x0,
 12875  	            0x8000001c: 0x20800,
 12876  	            0x8000001d: 0x820,
 12877  	            0x8000001e: 0x20020,
 12878  	            0x8000001f: 0x8020800
 12879  	        }
 12880  	    ];
 12881  
 12882  	    // Masks that select the SBOX input
 12883  	    var SBOX_MASK = [
 12884  	        0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000,
 12885  	        0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f
 12886  	    ];
 12887  
 12888  	    /**
 12889  	     * DES block cipher algorithm.
 12890  	     */
 12891  	    var DES = C_algo.DES = BlockCipher.extend({
 12892  	        _doReset: function () {
 12893  	            // Shortcuts
 12894  	            var key = this._key;
 12895  	            var keyWords = key.words;
 12896  
 12897  	            // Select 56 bits according to PC1
 12898  	            var keyBits = [];
 12899  	            for (var i = 0; i < 56; i++) {
 12900  	                var keyBitPos = PC1[i] - 1;
 12901  	                keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1;
 12902  	            }
 12903  
 12904  	            // Assemble 16 subkeys
 12905  	            var subKeys = this._subKeys = [];
 12906  	            for (var nSubKey = 0; nSubKey < 16; nSubKey++) {
 12907  	                // Create subkey
 12908  	                var subKey = subKeys[nSubKey] = [];
 12909  
 12910  	                // Shortcut
 12911  	                var bitShift = BIT_SHIFTS[nSubKey];
 12912  
 12913  	                // Select 48 bits according to PC2
 12914  	                for (var i = 0; i < 24; i++) {
 12915  	                    // Select from the left 28 key bits
 12916  	                    subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6);
 12917  
 12918  	                    // Select from the right 28 key bits
 12919  	                    subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6);
 12920  	                }
 12921  
 12922  	                // Since each subkey is applied to an expanded 32-bit input,
 12923  	                // the subkey can be broken into 8 values scaled to 32-bits,
 12924  	                // which allows the key to be used without expansion
 12925  	                subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31);
 12926  	                for (var i = 1; i < 7; i++) {
 12927  	                    subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3);
 12928  	                }
 12929  	                subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27);
 12930  	            }
 12931  
 12932  	            // Compute inverse subkeys
 12933  	            var invSubKeys = this._invSubKeys = [];
 12934  	            for (var i = 0; i < 16; i++) {
 12935  	                invSubKeys[i] = subKeys[15 - i];
 12936  	            }
 12937  	        },
 12938  
 12939  	        encryptBlock: function (M, offset) {
 12940  	            this._doCryptBlock(M, offset, this._subKeys);
 12941  	        },
 12942  
 12943  	        decryptBlock: function (M, offset) {
 12944  	            this._doCryptBlock(M, offset, this._invSubKeys);
 12945  	        },
 12946  
 12947  	        _doCryptBlock: function (M, offset, subKeys) {
 12948  	            // Get input
 12949  	            this._lBlock = M[offset];
 12950  	            this._rBlock = M[offset + 1];
 12951  
 12952  	            // Initial permutation
 12953  	            exchangeLR.call(this, 4,  0x0f0f0f0f);
 12954  	            exchangeLR.call(this, 16, 0x0000ffff);
 12955  	            exchangeRL.call(this, 2,  0x33333333);
 12956  	            exchangeRL.call(this, 8,  0x00ff00ff);
 12957  	            exchangeLR.call(this, 1,  0x55555555);
 12958  
 12959  	            // Rounds
 12960  	            for (var round = 0; round < 16; round++) {
 12961  	                // Shortcuts
 12962  	                var subKey = subKeys[round];
 12963  	                var lBlock = this._lBlock;
 12964  	                var rBlock = this._rBlock;
 12965  
 12966  	                // Feistel function
 12967  	                var f = 0;
 12968  	                for (var i = 0; i < 8; i++) {
 12969  	                    f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0];
 12970  	                }
 12971  	                this._lBlock = rBlock;
 12972  	                this._rBlock = lBlock ^ f;
 12973  	            }
 12974  
 12975  	            // Undo swap from last round
 12976  	            var t = this._lBlock;
 12977  	            this._lBlock = this._rBlock;
 12978  	            this._rBlock = t;
 12979  
 12980  	            // Final permutation
 12981  	            exchangeLR.call(this, 1,  0x55555555);
 12982  	            exchangeRL.call(this, 8,  0x00ff00ff);
 12983  	            exchangeRL.call(this, 2,  0x33333333);
 12984  	            exchangeLR.call(this, 16, 0x0000ffff);
 12985  	            exchangeLR.call(this, 4,  0x0f0f0f0f);
 12986  
 12987  	            // Set output
 12988  	            M[offset] = this._lBlock;
 12989  	            M[offset + 1] = this._rBlock;
 12990  	        },
 12991  
 12992  	        keySize: 64/32,
 12993  
 12994  	        ivSize: 64/32,
 12995  
 12996  	        blockSize: 64/32
 12997  	    });
 12998  
 12999  	    // Swap bits across the left and right words
 13000  	    function exchangeLR(offset, mask) {
 13001  	        var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;
 13002  	        this._rBlock ^= t;
 13003  	        this._lBlock ^= t << offset;
 13004  	    }
 13005  
 13006  	    function exchangeRL(offset, mask) {
 13007  	        var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;
 13008  	        this._lBlock ^= t;
 13009  	        this._rBlock ^= t << offset;
 13010  	    }
 13011  
 13012  	    /**
 13013  	     * Shortcut functions to the cipher's object interface.
 13014  	     *
 13015  	     * @example
 13016  	     *
 13017  	     *     var ciphertext = CryptoJS.DES.encrypt(message, key, cfg);
 13018  	     *     var plaintext  = CryptoJS.DES.decrypt(ciphertext, key, cfg);
 13019  	     */
 13020  	    C.DES = BlockCipher._createHelper(DES);
 13021  
 13022  	    /**
 13023  	     * Triple-DES block cipher algorithm.
 13024  	     */
 13025  	    var TripleDES = C_algo.TripleDES = BlockCipher.extend({
 13026  	        _doReset: function () {
 13027  	            // Shortcuts
 13028  	            var key = this._key;
 13029  	            var keyWords = key.words;
 13030  
 13031  	            // Create DES instances
 13032  	            this._des1 = DES.createEncryptor(WordArray.create(keyWords.slice(0, 2)));
 13033  	            this._des2 = DES.createEncryptor(WordArray.create(keyWords.slice(2, 4)));
 13034  	            this._des3 = DES.createEncryptor(WordArray.create(keyWords.slice(4, 6)));
 13035  	        },
 13036  
 13037  	        encryptBlock: function (M, offset) {
 13038  	            this._des1.encryptBlock(M, offset);
 13039  	            this._des2.decryptBlock(M, offset);
 13040  	            this._des3.encryptBlock(M, offset);
 13041  	        },
 13042  
 13043  	        decryptBlock: function (M, offset) {
 13044  	            this._des3.decryptBlock(M, offset);
 13045  	            this._des2.encryptBlock(M, offset);
 13046  	            this._des1.decryptBlock(M, offset);
 13047  	        },
 13048  
 13049  	        keySize: 192/32,
 13050  
 13051  	        ivSize: 64/32,
 13052  
 13053  	        blockSize: 64/32
 13054  	    });
 13055  
 13056  	    /**
 13057  	     * Shortcut functions to the cipher's object interface.
 13058  	     *
 13059  	     * @example
 13060  	     *
 13061  	     *     var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg);
 13062  	     *     var plaintext  = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg);
 13063  	     */
 13064  	    C.TripleDES = BlockCipher._createHelper(TripleDES);
 13065  	}());
 13066  
 13067  
 13068  	return CryptoJS.TripleDES;
 13069  
 13070  }));
 13071  },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],84:[function(require,module,exports){
 13072  ;(function (root, factory) {
 13073  	if (typeof exports === "object") {
 13074  		// CommonJS
 13075  		module.exports = exports = factory(require("./core"));
 13076  	}
 13077  	else if (typeof define === "function" && define.amd) {
 13078  		// AMD
 13079  		define(["./core"], factory);
 13080  	}
 13081  	else {
 13082  		// Global (browser)
 13083  		factory(root.CryptoJS);
 13084  	}
 13085  }(this, function (CryptoJS) {
 13086  
 13087  	(function (undefined) {
 13088  	    // Shortcuts
 13089  	    var C = CryptoJS;
 13090  	    var C_lib = C.lib;
 13091  	    var Base = C_lib.Base;
 13092  	    var X32WordArray = C_lib.WordArray;
 13093  
 13094  	    /**
 13095  	     * x64 namespace.
 13096  	     */
 13097  	    var C_x64 = C.x64 = {};
 13098  
 13099  	    /**
 13100  	     * A 64-bit word.
 13101  	     */
 13102  	    var X64Word = C_x64.Word = Base.extend({
 13103  	        /**
 13104  	         * Initializes a newly created 64-bit word.
 13105  	         *
 13106  	         * @param {number} high The high 32 bits.
 13107  	         * @param {number} low The low 32 bits.
 13108  	         *
 13109  	         * @example
 13110  	         *
 13111  	         *     var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
 13112  	         */
 13113  	        init: function (high, low) {
 13114  	            this.high = high;
 13115  	            this.low = low;
 13116  	        }
 13117  
 13118  	        /**
 13119  	         * Bitwise NOTs this word.
 13120  	         *
 13121  	         * @return {X64Word} A new x64-Word object after negating.
 13122  	         *
 13123  	         * @example
 13124  	         *
 13125  	         *     var negated = x64Word.not();
 13126  	         */
 13127  	        // not: function () {
 13128  	            // var high = ~this.high;
 13129  	            // var low = ~this.low;
 13130  
 13131  	            // return X64Word.create(high, low);
 13132  	        // },
 13133  
 13134  	        /**
 13135  	         * Bitwise ANDs this word with the passed word.
 13136  	         *
 13137  	         * @param {X64Word} word The x64-Word to AND with this word.
 13138  	         *
 13139  	         * @return {X64Word} A new x64-Word object after ANDing.
 13140  	         *
 13141  	         * @example
 13142  	         *
 13143  	         *     var anded = x64Word.and(anotherX64Word);
 13144  	         */
 13145  	        // and: function (word) {
 13146  	            // var high = this.high & word.high;
 13147  	            // var low = this.low & word.low;
 13148  
 13149  	            // return X64Word.create(high, low);
 13150  	        // },
 13151  
 13152  	        /**
 13153  	         * Bitwise ORs this word with the passed word.
 13154  	         *
 13155  	         * @param {X64Word} word The x64-Word to OR with this word.
 13156  	         *
 13157  	         * @return {X64Word} A new x64-Word object after ORing.
 13158  	         *
 13159  	         * @example
 13160  	         *
 13161  	         *     var ored = x64Word.or(anotherX64Word);
 13162  	         */
 13163  	        // or: function (word) {
 13164  	            // var high = this.high | word.high;
 13165  	            // var low = this.low | word.low;
 13166  
 13167  	            // return X64Word.create(high, low);
 13168  	        // },
 13169  
 13170  	        /**
 13171  	         * Bitwise XORs this word with the passed word.
 13172  	         *
 13173  	         * @param {X64Word} word The x64-Word to XOR with this word.
 13174  	         *
 13175  	         * @return {X64Word} A new x64-Word object after XORing.
 13176  	         *
 13177  	         * @example
 13178  	         *
 13179  	         *     var xored = x64Word.xor(anotherX64Word);
 13180  	         */
 13181  	        // xor: function (word) {
 13182  	            // var high = this.high ^ word.high;
 13183  	            // var low = this.low ^ word.low;
 13184  
 13185  	            // return X64Word.create(high, low);
 13186  	        // },
 13187  
 13188  	        /**
 13189  	         * Shifts this word n bits to the left.
 13190  	         *
 13191  	         * @param {number} n The number of bits to shift.
 13192  	         *
 13193  	         * @return {X64Word} A new x64-Word object after shifting.
 13194  	         *
 13195  	         * @example
 13196  	         *
 13197  	         *     var shifted = x64Word.shiftL(25);
 13198  	         */
 13199  	        // shiftL: function (n) {
 13200  	            // if (n < 32) {
 13201  	                // var high = (this.high << n) | (this.low >>> (32 - n));
 13202  	                // var low = this.low << n;
 13203  	            // } else {
 13204  	                // var high = this.low << (n - 32);
 13205  	                // var low = 0;
 13206  	            // }
 13207  
 13208  	            // return X64Word.create(high, low);
 13209  	        // },
 13210  
 13211  	        /**
 13212  	         * Shifts this word n bits to the right.
 13213  	         *
 13214  	         * @param {number} n The number of bits to shift.
 13215  	         *
 13216  	         * @return {X64Word} A new x64-Word object after shifting.
 13217  	         *
 13218  	         * @example
 13219  	         *
 13220  	         *     var shifted = x64Word.shiftR(7);
 13221  	         */
 13222  	        // shiftR: function (n) {
 13223  	            // if (n < 32) {
 13224  	                // var low = (this.low >>> n) | (this.high << (32 - n));
 13225  	                // var high = this.high >>> n;
 13226  	            // } else {
 13227  	                // var low = this.high >>> (n - 32);
 13228  	                // var high = 0;
 13229  	            // }
 13230  
 13231  	            // return X64Word.create(high, low);
 13232  	        // },
 13233  
 13234  	        /**
 13235  	         * Rotates this word n bits to the left.
 13236  	         *
 13237  	         * @param {number} n The number of bits to rotate.
 13238  	         *
 13239  	         * @return {X64Word} A new x64-Word object after rotating.
 13240  	         *
 13241  	         * @example
 13242  	         *
 13243  	         *     var rotated = x64Word.rotL(25);
 13244  	         */
 13245  	        // rotL: function (n) {
 13246  	            // return this.shiftL(n).or(this.shiftR(64 - n));
 13247  	        // },
 13248  
 13249  	        /**
 13250  	         * Rotates this word n bits to the right.
 13251  	         *
 13252  	         * @param {number} n The number of bits to rotate.
 13253  	         *
 13254  	         * @return {X64Word} A new x64-Word object after rotating.
 13255  	         *
 13256  	         * @example
 13257  	         *
 13258  	         *     var rotated = x64Word.rotR(7);
 13259  	         */
 13260  	        // rotR: function (n) {
 13261  	            // return this.shiftR(n).or(this.shiftL(64 - n));
 13262  	        // },
 13263  
 13264  	        /**
 13265  	         * Adds this word with the passed word.
 13266  	         *
 13267  	         * @param {X64Word} word The x64-Word to add with this word.
 13268  	         *
 13269  	         * @return {X64Word} A new x64-Word object after adding.
 13270  	         *
 13271  	         * @example
 13272  	         *
 13273  	         *     var added = x64Word.add(anotherX64Word);
 13274  	         */
 13275  	        // add: function (word) {
 13276  	            // var low = (this.low + word.low) | 0;
 13277  	            // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
 13278  	            // var high = (this.high + word.high + carry) | 0;
 13279  
 13280  	            // return X64Word.create(high, low);
 13281  	        // }
 13282  	    });
 13283  
 13284  	    /**
 13285  	     * An array of 64-bit words.
 13286  	     *
 13287  	     * @property {Array} words The array of CryptoJS.x64.Word objects.
 13288  	     * @property {number} sigBytes The number of significant bytes in this word array.
 13289  	     */
 13290  	    var X64WordArray = C_x64.WordArray = Base.extend({
 13291  	        /**
 13292  	         * Initializes a newly created word array.
 13293  	         *
 13294  	         * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.
 13295  	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
 13296  	         *
 13297  	         * @example
 13298  	         *
 13299  	         *     var wordArray = CryptoJS.x64.WordArray.create();
 13300  	         *
 13301  	         *     var wordArray = CryptoJS.x64.WordArray.create([
 13302  	         *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
 13303  	         *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
 13304  	         *     ]);
 13305  	         *
 13306  	         *     var wordArray = CryptoJS.x64.WordArray.create([
 13307  	         *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
 13308  	         *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
 13309  	         *     ], 10);
 13310  	         */
 13311  	        init: function (words, sigBytes) {
 13312  	            words = this.words = words || [];
 13313  
 13314  	            if (sigBytes != undefined) {
 13315  	                this.sigBytes = sigBytes;
 13316  	            } else {
 13317  	                this.sigBytes = words.length * 8;
 13318  	            }
 13319  	        },
 13320  
 13321  	        /**
 13322  	         * Converts this 64-bit word array to a 32-bit word array.
 13323  	         *
 13324  	         * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.
 13325  	         *
 13326  	         * @example
 13327  	         *
 13328  	         *     var x32WordArray = x64WordArray.toX32();
 13329  	         */
 13330  	        toX32: function () {
 13331  	            // Shortcuts
 13332  	            var x64Words = this.words;
 13333  	            var x64WordsLength = x64Words.length;
 13334  
 13335  	            // Convert
 13336  	            var x32Words = [];
 13337  	            for (var i = 0; i < x64WordsLength; i++) {
 13338  	                var x64Word = x64Words[i];
 13339  	                x32Words.push(x64Word.high);
 13340  	                x32Words.push(x64Word.low);
 13341  	            }
 13342  
 13343  	            return X32WordArray.create(x32Words, this.sigBytes);
 13344  	        },
 13345  
 13346  	        /**
 13347  	         * Creates a copy of this word array.
 13348  	         *
 13349  	         * @return {X64WordArray} The clone.
 13350  	         *
 13351  	         * @example
 13352  	         *
 13353  	         *     var clone = x64WordArray.clone();
 13354  	         */
 13355  	        clone: function () {
 13356  	            var clone = Base.clone.call(this);
 13357  
 13358  	            // Clone "words" array
 13359  	            var words = clone.words = this.words.slice(0);
 13360  
 13361  	            // Clone each X64Word object
 13362  	            var wordsLength = words.length;
 13363  	            for (var i = 0; i < wordsLength; i++) {
 13364  	                words[i] = words[i].clone();
 13365  	            }
 13366  
 13367  	            return clone;
 13368  	        }
 13369  	    });
 13370  	}());
 13371  
 13372  
 13373  	return CryptoJS;
 13374  
 13375  }));
 13376  },{"./core":53}],85:[function(require,module,exports){
 13377  /*! https://mths.be/utf8js v2.1.2 by @mathias */
 13378  ;(function(root) {
 13379  
 13380  	// Detect free variables `exports`
 13381  	var freeExports = typeof exports == 'object' && exports;
 13382  
 13383  	// Detect free variable `module`
 13384  	var freeModule = typeof module == 'object' && module &&
 13385  		module.exports == freeExports && module;
 13386  
 13387  	// Detect free variable `global`, from Node.js or Browserified code,
 13388  	// and use it as `root`
 13389  	var freeGlobal = typeof global == 'object' && global;
 13390  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
 13391  		root = freeGlobal;
 13392  	}
 13393  
 13394  	/*--------------------------------------------------------------------------*/
 13395  
 13396  	var stringFromCharCode = String.fromCharCode;
 13397  
 13398  	// Taken from https://mths.be/punycode
 13399  	function ucs2decode(string) {
 13400  		var output = [];
 13401  		var counter = 0;
 13402  		var length = string.length;
 13403  		var value;
 13404  		var extra;
 13405  		while (counter < length) {
 13406  			value = string.charCodeAt(counter++);
 13407  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
 13408  				// high surrogate, and there is a next character
 13409  				extra = string.charCodeAt(counter++);
 13410  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
 13411  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
 13412  				} else {
 13413  					// unmatched surrogate; only append this code unit, in case the next
 13414  					// code unit is the high surrogate of a surrogate pair
 13415  					output.push(value);
 13416  					counter--;
 13417  				}
 13418  			} else {
 13419  				output.push(value);
 13420  			}
 13421  		}
 13422  		return output;
 13423  	}
 13424  
 13425  	// Taken from https://mths.be/punycode
 13426  	function ucs2encode(array) {
 13427  		var length = array.length;
 13428  		var index = -1;
 13429  		var value;
 13430  		var output = '';
 13431  		while (++index < length) {
 13432  			value = array[index];
 13433  			if (value > 0xFFFF) {
 13434  				value -= 0x10000;
 13435  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
 13436  				value = 0xDC00 | value & 0x3FF;
 13437  			}
 13438  			output += stringFromCharCode(value);
 13439  		}
 13440  		return output;
 13441  	}
 13442  
 13443  	function checkScalarValue(codePoint) {
 13444  		if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
 13445  			throw Error(
 13446  				'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
 13447  				' is not a scalar value'
 13448  			);
 13449  		}
 13450  	}
 13451  	/*--------------------------------------------------------------------------*/
 13452  
 13453  	function createByte(codePoint, shift) {
 13454  		return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
 13455  	}
 13456  
 13457  	function encodeCodePoint(codePoint) {
 13458  		if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
 13459  			return stringFromCharCode(codePoint);
 13460  		}
 13461  		var symbol = '';
 13462  		if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
 13463  			symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
 13464  		}
 13465  		else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
 13466  			checkScalarValue(codePoint);
 13467  			symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
 13468  			symbol += createByte(codePoint, 6);
 13469  		}
 13470  		else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
 13471  			symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
 13472  			symbol += createByte(codePoint, 12);
 13473  			symbol += createByte(codePoint, 6);
 13474  		}
 13475  		symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
 13476  		return symbol;
 13477  	}
 13478  
 13479  	function utf8encode(string) {
 13480  		var codePoints = ucs2decode(string);
 13481  		var length = codePoints.length;
 13482  		var index = -1;
 13483  		var codePoint;
 13484  		var byteString = '';
 13485  		while (++index < length) {
 13486  			codePoint = codePoints[index];
 13487  			byteString += encodeCodePoint(codePoint);
 13488  		}
 13489  		return byteString;
 13490  	}
 13491  
 13492  	/*--------------------------------------------------------------------------*/
 13493  
 13494  	function readContinuationByte() {
 13495  		if (byteIndex >= byteCount) {
 13496  			throw Error('Invalid byte index');
 13497  		}
 13498  
 13499  		var continuationByte = byteArray[byteIndex] & 0xFF;
 13500  		byteIndex++;
 13501  
 13502  		if ((continuationByte & 0xC0) == 0x80) {
 13503  			return continuationByte & 0x3F;
 13504  		}
 13505  
 13506  		// If we end up here, it’s not a continuation byte
 13507  		throw Error('Invalid continuation byte');
 13508  	}
 13509  
 13510  	function decodeSymbol() {
 13511  		var byte1;
 13512  		var byte2;
 13513  		var byte3;
 13514  		var byte4;
 13515  		var codePoint;
 13516  
 13517  		if (byteIndex > byteCount) {
 13518  			throw Error('Invalid byte index');
 13519  		}
 13520  
 13521  		if (byteIndex == byteCount) {
 13522  			return false;
 13523  		}
 13524  
 13525  		// Read first byte
 13526  		byte1 = byteArray[byteIndex] & 0xFF;
 13527  		byteIndex++;
 13528  
 13529  		// 1-byte sequence (no continuation bytes)
 13530  		if ((byte1 & 0x80) == 0) {
 13531  			return byte1;
 13532  		}
 13533  
 13534  		// 2-byte sequence
 13535  		if ((byte1 & 0xE0) == 0xC0) {
 13536  			byte2 = readContinuationByte();
 13537  			codePoint = ((byte1 & 0x1F) << 6) | byte2;
 13538  			if (codePoint >= 0x80) {
 13539  				return codePoint;
 13540  			} else {
 13541  				throw Error('Invalid continuation byte');
 13542  			}
 13543  		}
 13544  
 13545  		// 3-byte sequence (may include unpaired surrogates)
 13546  		if ((byte1 & 0xF0) == 0xE0) {
 13547  			byte2 = readContinuationByte();
 13548  			byte3 = readContinuationByte();
 13549  			codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
 13550  			if (codePoint >= 0x0800) {
 13551  				checkScalarValue(codePoint);
 13552  				return codePoint;
 13553  			} else {
 13554  				throw Error('Invalid continuation byte');
 13555  			}
 13556  		}
 13557  
 13558  		// 4-byte sequence
 13559  		if ((byte1 & 0xF8) == 0xF0) {
 13560  			byte2 = readContinuationByte();
 13561  			byte3 = readContinuationByte();
 13562  			byte4 = readContinuationByte();
 13563  			codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
 13564  				(byte3 << 0x06) | byte4;
 13565  			if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
 13566  				return codePoint;
 13567  			}
 13568  		}
 13569  
 13570  		throw Error('Invalid UTF-8 detected');
 13571  	}
 13572  
 13573  	var byteArray;
 13574  	var byteCount;
 13575  	var byteIndex;
 13576  	function utf8decode(byteString) {
 13577  		byteArray = ucs2decode(byteString);
 13578  		byteCount = byteArray.length;
 13579  		byteIndex = 0;
 13580  		var codePoints = [];
 13581  		var tmp;
 13582  		while ((tmp = decodeSymbol()) !== false) {
 13583  			codePoints.push(tmp);
 13584  		}
 13585  		return ucs2encode(codePoints);
 13586  	}
 13587  
 13588  	/*--------------------------------------------------------------------------*/
 13589  
 13590  	var utf8 = {
 13591  		'version': '2.1.2',
 13592  		'encode': utf8encode,
 13593  		'decode': utf8decode
 13594  	};
 13595  
 13596  	// Some AMD build optimizers, like r.js, check for specific condition patterns
 13597  	// like the following:
 13598  	if (
 13599  		typeof define == 'function' &&
 13600  		typeof define.amd == 'object' &&
 13601  		define.amd
 13602  	) {
 13603  		define(function() {
 13604  			return utf8;
 13605  		});
 13606  	}	else if (freeExports && !freeExports.nodeType) {
 13607  		if (freeModule) { // in Node.js or RingoJS v0.8.0+
 13608  			freeModule.exports = utf8;
 13609  		} else { // in Narwhal or RingoJS v0.7.0-
 13610  			var object = {};
 13611  			var hasOwnProperty = object.hasOwnProperty;
 13612  			for (var key in utf8) {
 13613  				hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);
 13614  			}
 13615  		}
 13616  	} else { // in Rhino or a web browser
 13617  		root.utf8 = utf8;
 13618  	}
 13619  
 13620  }(this));
 13621  
 13622  },{}],86:[function(require,module,exports){
 13623  module.exports = XMLHttpRequest;
 13624  
 13625  },{}],"bignumber.js":[function(require,module,exports){
 13626  'use strict';
 13627  
 13628  module.exports = BigNumber; // jshint ignore:line
 13629  
 13630  
 13631  },{}],"web3":[function(require,module,exports){
 13632  var Web3 = require('./lib/web3');
 13633  
 13634  // dont override global variable
 13635  if (typeof window !== 'undefined' && typeof window.Web3 === 'undefined') {
 13636      window.Web3 = Web3;
 13637  }
 13638  
 13639  module.exports = Web3;
 13640  
 13641  },{"./lib/web3":22}]},{},["web3"])
 13642  //# sourceMappingURL=web3-light.js.map