darkwallet/darkwallet

View on GitHub
src/vendors/crypto-js/cryptojs.js

Summary

Maintainability
F
3 mos
Test Coverage

File cryptojs.js has 3574 lines of code (exceeds 250 allowed). Consider refactoring.
Open

!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.CryptoJS=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
;(function (root, factory, undef) {
    if (typeof exports === "object") {
        // CommonJS
        module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
Severity: Major
Found in src/vendors/crypto-js/cryptojs.js - About 1 wk to fix

    Function 32 has 676 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    },{"./core":3,"./x64-core":33}],32:[function(require,module,exports){
    ;(function (root, factory, undef) {
        if (typeof exports === "object") {
            // CommonJS
            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
    Severity: Major
    Found in src/vendors/crypto-js/cryptojs.js - About 3 days to fix

      Function 2 has 280 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      },{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":10}],2:[function(require,module,exports){
      ;(function (root, factory) {
          if (typeof exports === "object") {
              // CommonJS
              module.exports = exports = factory(require("./core"));
      Severity: Major
      Found in src/vendors/crypto-js/cryptojs.js - About 1 day to fix

        Function 3 has 256 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        },{"./core":3}],3:[function(require,module,exports){
        ;(function (root, factory) {
            if (typeof exports === "object") {
                // CommonJS
                module.exports = exports = factory();
        Severity: Major
        Found in src/vendors/crypto-js/cryptojs.js - About 1 day to fix

          Function CryptoJS has 241 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              var CryptoJS = CryptoJS || (function (Math, undefined) {
                  /**
                   * CryptoJS namespace.
                   */
                  var C = {};
          Severity: Major
          Found in src/vendors/crypto-js/cryptojs.js - About 1 day to fix

            Function 31 has 232 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            },{"./core":3,"./sha512":31,"./x64-core":33}],31:[function(require,module,exports){
            ;(function (root, factory, undef) {
                if (typeof exports === "object") {
                    // CommonJS
                    module.exports = exports = factory(require("./core"), require("./x64-core"));
            Severity: Major
            Found in src/vendors/crypto-js/cryptojs.js - About 1 day to fix

              Function 29 has 198 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              },{"./core":3}],29:[function(require,module,exports){
              ;(function (root, factory, undef) {
                  if (typeof exports === "object") {
                      // CommonJS
                      module.exports = exports = factory(require("./core"), require("./x64-core"));
              Severity: Major
              Found in src/vendors/crypto-js/cryptojs.js - About 7 hrs to fix

                Function 10 has 183 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                },{"./core":3}],10:[function(require,module,exports){
                ;(function (root, factory) {
                    if (typeof exports === "object") {
                        // CommonJS
                        module.exports = exports = factory(require("./core"));
                Severity: Major
                Found in src/vendors/crypto-js/cryptojs.js - About 7 hrs to fix

                  Function 25 has 170 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  },{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":10}],25:[function(require,module,exports){
                  ;(function (root, factory) {
                      if (typeof exports === "object") {
                          // CommonJS
                          module.exports = exports = factory(require("./core"));
                  Severity: Major
                  Found in src/vendors/crypto-js/cryptojs.js - About 6 hrs to fix

                    Function 1 has 147 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.CryptoJS=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
                    ;(function (root, factory, undef) {
                        if (typeof exports === "object") {
                            // CommonJS
                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                    Severity: Major
                    Found in src/vendors/crypto-js/cryptojs.js - About 5 hrs to fix

                      Function _doProcessBlock has 126 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                                  _doProcessBlock: function (M, offset) {
                                      // Shortcuts
                                      var H = this._hash.words;
                      
                                      var H0 = H[0];
                      Severity: Major
                      Found in src/vendors/crypto-js/cryptojs.js - About 5 hrs to fix

                        Function 28 has 121 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        },{"./core":3,"./sha256":28}],28:[function(require,module,exports){
                        ;(function (root, factory) {
                            if (typeof exports === "object") {
                                // CommonJS
                                module.exports = exports = factory(require("./core"));
                        Severity: Major
                        Found in src/vendors/crypto-js/cryptojs.js - About 4 hrs to fix

                          Function 23 has 119 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          },{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":10}],23:[function(require,module,exports){
                          ;(function (root, factory, undef) {
                              if (typeof exports === "object") {
                                  // CommonJS
                                  module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                          Severity: Major
                          Found in src/vendors/crypto-js/cryptojs.js - About 4 hrs to fix

                            Function 22 has 115 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            },{"./core":3,"./hmac":8,"./sha1":26}],22:[function(require,module,exports){
                            ;(function (root, factory, undef) {
                                if (typeof exports === "object") {
                                    // CommonJS
                                    module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                            Severity: Major
                            Found in src/vendors/crypto-js/cryptojs.js - About 4 hrs to fix

                              Function _doProcessBlock has 97 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                          _doProcessBlock: function (M, offset) {
                                              // Swap endian
                                              for (var i = 0; i < 16; i++) {
                                                  // Shortcuts
                                                  var offset_i = offset + i;
                              Severity: Major
                              Found in src/vendors/crypto-js/cryptojs.js - About 3 hrs to fix

                                Function 12 has 85 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                },{"./cipher-core":2,"./core":3}],12:[function(require,module,exports){
                                ;(function (root, factory, undef) {
                                    if (typeof exports === "object") {
                                        // CommonJS
                                        module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                Severity: Major
                                Found in src/vendors/crypto-js/cryptojs.js - About 3 hrs to fix

                                  Function 26 has 84 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  },{"./core":3}],26:[function(require,module,exports){
                                  ;(function (root, factory) {
                                      if (typeof exports === "object") {
                                          // CommonJS
                                          module.exports = exports = factory(require("./core"));
                                  Severity: Major
                                  Found in src/vendors/crypto-js/cryptojs.js - About 3 hrs to fix

                                    Function _doProcessBlock has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                                _doProcessBlock: function (M, offset) {
                                                    // Shortcuts
                                                    var state = this._state;
                                                    var nBlockSizeLanes = this.blockSize / 2;
                                    
                                    
                                    Severity: Major
                                    Found in src/vendors/crypto-js/cryptojs.js - About 3 hrs to fix

                                      Function 24 has 74 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                      },{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":10}],24:[function(require,module,exports){
                                      ;(function (root, factory, undef) {
                                          if (typeof exports === "object") {
                                              // CommonJS
                                              module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                      Severity: Major
                                      Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                        Function _doProcessBlock has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                                    _doProcessBlock: function (M, offset) {
                                        
                                                        // Swap endian
                                                        for (var i = 0; i < 16; i++) {
                                                            // Shortcuts
                                        Severity: Major
                                        Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                          Function CTRGladman has 70 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                              CryptoJS.mode.CTRGladman = (function () {
                                                  var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
                                          
                                                  function incWord(word)
                                                  {
                                          Severity: Major
                                          Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                            Function 4 has 67 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                            },{}],4:[function(require,module,exports){
                                            ;(function (root, factory) {
                                                if (typeof exports === "object") {
                                                    // CommonJS
                                                    module.exports = exports = factory(require("./core"));
                                            Severity: Major
                                            Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                              Function 21 has 64 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                              },{"./cipher-core":2,"./core":3}],21:[function(require,module,exports){
                                              ;(function (root, factory, undef) {
                                                  if (typeof exports === "object") {
                                                      // CommonJS
                                                      module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
                                              Severity: Major
                                              Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                                Function 5 has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                },{"./core":3}],5:[function(require,module,exports){
                                                ;(function (root, factory) {
                                                    if (typeof exports === "object") {
                                                        // CommonJS
                                                        module.exports = exports = factory(require("./core"));
                                                Severity: Major
                                                Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                                  Function 8 has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                  },{"./cipher-core":2,"./core":3}],8:[function(require,module,exports){
                                                  ;(function (root, factory) {
                                                      if (typeof exports === "object") {
                                                          // CommonJS
                                                          module.exports = exports = factory(require("./core"));
                                                  Severity: Major
                                                  Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                                    Function 6 has 56 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                    },{"./core":3}],6:[function(require,module,exports){
                                                    ;(function (root, factory, undef) {
                                                        if (typeof exports === "object") {
                                                            // CommonJS
                                                            module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
                                                    Severity: Major
                                                    Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                                      Function 33 has 56 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                      },{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":10}],33:[function(require,module,exports){
                                                      ;(function (root, factory) {
                                                          if (typeof exports === "object") {
                                                              // CommonJS
                                                              module.exports = exports = factory(require("./core"));
                                                      Severity: Major
                                                      Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                                        Function 9 has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                        },{"./core":3}],9:[function(require,module,exports){
                                                        ;(function (root, factory) {
                                                            if (typeof exports === "object") {
                                                                // CommonJS
                                                                module.exports = exports = factory(require("./core"));
                                                        Severity: Minor
                                                        Found in src/vendors/crypto-js/cryptojs.js - About 2 hrs to fix

                                                          Function 11 has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                          },{"./core":3}],11:[function(require,module,exports){
                                                          ;(function (root, factory, undef) {
                                                              if (typeof exports === "object") {
                                                                  // CommonJS
                                                                  module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                          Severity: Minor
                                                          Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                            Function _doProcessBlock has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                                        _doProcessBlock: function (M, offset) {
                                                                            // Shortcut
                                                                            var H = this._hash.words;
                                                            
                                                                            // Working variables
                                                            Severity: Minor
                                                            Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                              Function _doReset has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                                          _doReset: function () {
                                                                              // Shortcuts
                                                                              var K = this._key.words;
                                                                              var iv = this.cfg.iv;
                                                              
                                                              
                                                              Severity: Minor
                                                              Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                Function _doReset has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                            _doReset: function () {
                                                                                // Shortcuts
                                                                                var K = this._key.words;
                                                                                var iv = this.cfg.iv;
                                                                
                                                                
                                                                Severity: Minor
                                                                Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                  Function Base has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                          var Base = C_lib.Base = (function () {
                                                                              function F() {}
                                                                  
                                                                              return {
                                                                                  /**
                                                                  Severity: Minor
                                                                  Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                    Function incWord has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                            function incWord(word)
                                                                            {
                                                                                if (((word >> 24) & 0xff) === 0xff) { //overflow
                                                                                var b1 = (word >> 16)&0xff;
                                                                                var b2 = (word >> 8)&0xff;
                                                                    Severity: Minor
                                                                    Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                      Function 30 has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                      Open

                                                                      },{"./core":3,"./x64-core":33}],30:[function(require,module,exports){
                                                                      ;(function (root, factory, undef) {
                                                                          if (typeof exports === "object") {
                                                                              // CommonJS
                                                                              module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"));
                                                                      Severity: Minor
                                                                      Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                        Function _doReset has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                                    _doReset: function () {
                                                                                        // Shortcuts
                                                                                        var key = this._key;
                                                                                        var keyWords = key.words;
                                                                                        var keySize = key.sigBytes / 4;
                                                                        Severity: Minor
                                                                        Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                          Function 13 has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                          },{"./cipher-core":2,"./core":3}],13:[function(require,module,exports){
                                                                          ;(function (root, factory, undef) {
                                                                              if (typeof exports === "object") {
                                                                                  // CommonJS
                                                                                  module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                          Severity: Minor
                                                                          Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                            Function 27 has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                            Open

                                                                            },{"./core":3}],27:[function(require,module,exports){
                                                                            ;(function (root, factory, undef) {
                                                                                if (typeof exports === "object") {
                                                                                    // CommonJS
                                                                                    module.exports = exports = factory(require("./core"), require("./sha256"));
                                                                            Severity: Minor
                                                                            Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                              Function 15 has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                              },{"./cipher-core":2,"./core":3}],15:[function(require,module,exports){
                                                                              ;(function (root, factory, undef) {
                                                                                  if (typeof exports === "object") {
                                                                                      // CommonJS
                                                                                      module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                              Severity: Minor
                                                                              Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                Consider simplifying this complex logical expression.
                                                                                Open

                                                                                            if (
                                                                                                typedArray instanceof Int8Array ||
                                                                                                typedArray instanceof Uint8ClampedArray ||
                                                                                                typedArray instanceof Int16Array ||
                                                                                                typedArray instanceof Uint16Array ||
                                                                                Severity: Critical
                                                                                Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                  Function CBC has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                          var CBC = C_mode.CBC = (function () {
                                                                                              /**
                                                                                               * Abstract base CBC mode.
                                                                                               */
                                                                                              var CBC = BlockCipherMode.extend();
                                                                                  Severity: Minor
                                                                                  Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                    Function _doProcessBlock has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                    Open

                                                                                                _doProcessBlock: function (M, offset) {
                                                                                                    // Shortcut
                                                                                                    var H = this._hash.words;
                                                                                    
                                                                                                    // Working variables
                                                                                    Severity: Minor
                                                                                    Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                      Function CFB has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                      Open

                                                                                          CryptoJS.mode.CFB = (function () {
                                                                                              var CFB = CryptoJS.lib.BlockCipherMode.extend();
                                                                                      
                                                                                              CFB.Encryptor = CFB.extend({
                                                                                                  processBlock: function (words, offset) {
                                                                                      Severity: Minor
                                                                                      Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                        Function 7 has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                        },{"./core":3,"./hmac":8,"./sha1":26}],7:[function(require,module,exports){
                                                                                        ;(function (root, factory, undef) {
                                                                                            if (typeof exports === "object") {
                                                                                                // CommonJS
                                                                                                module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                        Severity: Minor
                                                                                        Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                          Function nextState has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                          Open

                                                                                                  function nextState() {
                                                                                                      // Shortcuts
                                                                                                      var X = this._X;
                                                                                                      var C = this._C;
                                                                                          
                                                                                          
                                                                                          Severity: Minor
                                                                                          Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                            Function nextState has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                            Open

                                                                                                    function nextState() {
                                                                                                        // Shortcuts
                                                                                                        var X = this._X;
                                                                                                        var C = this._C;
                                                                                            
                                                                                            
                                                                                            Severity: Minor
                                                                                            Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                              Function _doFinalize has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                              Open

                                                                                                          _doFinalize: function () {
                                                                                                              // Shortcuts
                                                                                                              var data = this._data;
                                                                                                              var dataWords = data.words;
                                                                                                              var nBitsTotal = this._nDataBytes * 8;
                                                                                              Severity: Minor
                                                                                              Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                Function 16 has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                Open

                                                                                                },{"./cipher-core":2,"./core":3}],16:[function(require,module,exports){
                                                                                                ;(function (root, factory, undef) {
                                                                                                    if (typeof exports === "object") {
                                                                                                        // CommonJS
                                                                                                        module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                Severity: Minor
                                                                                                Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                  Function 20 has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  },{"./cipher-core":2,"./core":3}],20:[function(require,module,exports){
                                                                                                  ;(function (root, factory, undef) {
                                                                                                      if (typeof exports === "object") {
                                                                                                          // CommonJS
                                                                                                          module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                    Function _doCryptBlock has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                                _doCryptBlock: function (M, offset, subKeys) {
                                                                                                                    // Get input
                                                                                                                    this._lBlock = M[offset];
                                                                                                                    this._rBlock = M[offset + 1];
                                                                                                    
                                                                                                    
                                                                                                    Severity: Minor
                                                                                                    Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                      Function compute has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                                  compute: function (password, salt) {
                                                                                                                      // Shortcut
                                                                                                                      var cfg = this.cfg;
                                                                                                      
                                                                                                                      // Init HMAC
                                                                                                      Severity: Minor
                                                                                                      Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                        Function 14 has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                        Open

                                                                                                        },{"./cipher-core":2,"./core":3}],14:[function(require,module,exports){
                                                                                                        ;(function (root, factory, undef) {
                                                                                                            if (typeof exports === "object") {
                                                                                                                // CommonJS
                                                                                                                module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                        Severity: Minor
                                                                                                        Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                          Function _doCryptBlock has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                          Open

                                                                                                                      _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
                                                                                                          Severity: Major
                                                                                                          Found in src/vendors/crypto-js/cryptojs.js - About 1 hr to fix

                                                                                                            Function HH has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                                    function HH(a, b, c, d, x, s, t) {
                                                                                                            Severity: Major
                                                                                                            Found in src/vendors/crypto-js/cryptojs.js - About 50 mins to fix

                                                                                                              Function FF has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                                      function FF(a, b, c, d, x, s, t) {
                                                                                                              Severity: Major
                                                                                                              Found in src/vendors/crypto-js/cryptojs.js - About 50 mins to fix

                                                                                                                Function GG has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                Open

                                                                                                                        function GG(a, b, c, d, x, s, t) {
                                                                                                                Severity: Major
                                                                                                                Found in src/vendors/crypto-js/cryptojs.js - About 50 mins to fix

                                                                                                                  Function II has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                  Open

                                                                                                                          function II(a, b, c, d, x, s, t) {
                                                                                                                  Severity: Major
                                                                                                                  Found in src/vendors/crypto-js/cryptojs.js - About 50 mins to fix

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            function nextState() {
                                                                                                                                // Shortcuts
                                                                                                                                var X = this._X;
                                                                                                                                var C = this._C;
                                                                                                                    
                                                                                                                    
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 wk to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3846..3892

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 1160.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            function nextState() {
                                                                                                                                // Shortcuts
                                                                                                                                var X = this._X;
                                                                                                                                var C = this._C;
                                                                                                                    
                                                                                                                    
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 wk to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3653..3699

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 1160.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    for (var i = 0; i < 80; i += 1) {
                                                                                                                                        t = (al +  M[offset+zl[i]])|0;
                                                                                                                                        if (i<16){
                                                                                                                                        t +=  f1(bl,cl,dl) + hl[0];
                                                                                                                                        } else if (i<32) {
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 3 days to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2264..2306

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 561.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x8000820,
                                                                                                                                    0x1: 0x20000,
                                                                                                                                    0x2: 0x8000000,
                                                                                                                                    0x3: 0x20,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x80401000,
                                                                                                                                    0x10000: 0x80001040,
                                                                                                                                    0x20000: 0x401040,
                                                                                                                                    0x30000: 0x80400000,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x808200,
                                                                                                                                    0x10000000: 0x8000,
                                                                                                                                    0x20000000: 0x808002,
                                                                                                                                    0x30000000: 0x2,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x104,
                                                                                                                                    0x100000: 0x0,
                                                                                                                                    0x200000: 0x4000100,
                                                                                                                                    0x300000: 0x10104,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x80,
                                                                                                                                    0x1000: 0x1040000,
                                                                                                                                    0x2000: 0x40000,
                                                                                                                                    0x3000: 0x20000000,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x100000,
                                                                                                                                    0x10: 0x2000401,
                                                                                                                                    0x20: 0x400,
                                                                                                                                    0x30: 0x100401,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x10000008,
                                                                                                                                    0x100: 0x2000,
                                                                                                                                    0x200: 0x10200000,
                                                                                                                                    0x300: 0x10202008,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5599..5664
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                {
                                                                                                                                    0x0: 0x40084010,
                                                                                                                                    0x1000000: 0x4000,
                                                                                                                                    0x2000000: 0x80000,
                                                                                                                                    0x3000000: 0x40080010,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 7 other locations - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5533..5598
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5665..5730
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5731..5796
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5797..5862
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5863..5928
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5929..5994
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5995..6060

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 322.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                _doProcessBlock: function (M, offset) {
                                                                                                                                    // Shortcut
                                                                                                                                    var X = this._X;
                                                                                                                    
                                                                                                                                    // Iterate the system
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3625..3646

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 311.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                _doProcessBlock: function (M, offset) {
                                                                                                                                    // Shortcut
                                                                                                                                    var X = this._X;
                                                                                                                    
                                                                                                                                    // Iterate the system
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3818..3839

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 311.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    if (iv) {
                                                                                                                                        // Shortcuts
                                                                                                                                        var IV = iv.words;
                                                                                                                                        var IV_0 = IV[0];
                                                                                                                                        var IV_1 = IV[1];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3596..3622

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 302.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    if (iv) {
                                                                                                                                        // Shortcuts
                                                                                                                                        var IV = iv.words;
                                                                                                                                        var IV_0 = IV[0];
                                                                                                                                        var IV_1 = IV[1];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3789..3815

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 302.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.CryptoJS=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 1..8741

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 292.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                _doFinalize: function () {
                                                                                                                                    // Shortcuts
                                                                                                                                    var data = this._data;
                                                                                                                                    var dataWords = data.words;
                                                                                                                    
                                                                                                                    
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4683..4702

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 205.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                _doFinalize: function () {
                                                                                                                                    // Shortcuts
                                                                                                                                    var data = this._data;
                                                                                                                                    var dataWords = data.words;
                                                                                                                    
                                                                                                                    
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 day to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4402..4421

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 205.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    var C = this._C = [
                                                                                                                                        (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
                                                                                                                                        (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
                                                                                                                                        (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
                                                                                                                                        (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 7 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3768..3773

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 188.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    var C = this._C = [
                                                                                                                                        (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
                                                                                                                                        (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
                                                                                                                                        (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
                                                                                                                                        (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 7 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3575..3580

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 188.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    var X = this._X = [
                                                                                                                                        K[0], (K[3] << 16) | (K[2] >>> 16),
                                                                                                                                        K[1], (K[0] << 16) | (K[3] >>> 16),
                                                                                                                                        K[2], (K[1] << 16) | (K[0] >>> 16),
                                                                                                                                        K[3], (K[2] << 16) | (K[1] >>> 16)
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3760..3765

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 124.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    var X = this._X = [
                                                                                                                                        K[0], (K[3] << 16) | (K[2] >>> 16),
                                                                                                                                        K[1], (K[0] << 16) | (K[3] >>> 16),
                                                                                                                                        K[2], (K[1] << 16) | (K[0] >>> 16),
                                                                                                                                        K[3], (K[2] << 16) | (K[1] >>> 16)
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3567..3572

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 124.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2..228
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3526..3715
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3910..4048
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5482..6251

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 123.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2..228
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3717..3908
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3910..4048
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5482..6251

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 123.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3526..3715
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3717..3908
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3910..4048
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5482..6251

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 123.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2..228
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3526..3715
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3717..3908
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3910..4048

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 123.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 4 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2..228
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3526..3715
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3717..3908
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5482..6251

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 123.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2126..2257
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5074..5156

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 111.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3380..3524
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5074..5156

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 111.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2126..2257
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3380..3524

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 111.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                _doReset: function () {
                                                                                                                                    this._hash = new X64WordArray.init([
                                                                                                                                        new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),
                                                                                                                                        new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),
                                                                                                                                        new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5102..5109

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 110.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                _doReset: function () {
                                                                                                                                    this._hash = new X64WordArray.init([
                                                                                                                                        new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507),
                                                                                                                                        new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939),
                                                                                                                                        new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511),
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5243..5250

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 110.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./sha256"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./x64-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./x64-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2816..2893
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 14 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory, undef) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"), require("./cipher-core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 13 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2259..2324
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2895..3010
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3012..3069
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3071..3110
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3112..3165
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3167..3215
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3217..3260
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3262..3301
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3303..3332
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3334..3378
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4469..4548
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4750..5072
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5158..5480

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2547..2814
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 10 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                    ;(function (root, factory) {
                                                                                                                        if (typeof exports === "object") {
                                                                                                                            // CommonJS
                                                                                                                            module.exports = exports = factory(require("./core"));
                                                                                                                        }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 9 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 230..1104
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1852..1974
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1976..2124
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2326..2468
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2470..2545
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4050..4316
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4318..4467
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4550..4748
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6253..6556

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 98.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            var _zr = WordArray.create([
                                                                                                                                5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
                                                                                                                                6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
                                                                                                                                15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
                                                                                                                                8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4097..4102
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4103..4108

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 96.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            var _sr = WordArray.create([
                                                                                                                                8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
                                                                                                                                9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
                                                                                                                                9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
                                                                                                                                15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4091..4096
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4097..4102

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 96.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            var _sl = WordArray.create([
                                                                                                                                 11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
                                                                                                                                7, 6,   8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
                                                                                                                                11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
                                                                                                                                  11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 3 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4091..4096
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4103..4108

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 96.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 2 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 200..200

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 81.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 2 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 201..201

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 81.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                init: function (words, sigBytes) {
                                                                                                                                    words = this.words = words || [];
                                                                                                                    
                                                                                                                                    if (sigBytes != undefined) {
                                                                                                                                        this.sigBytes = sigBytes;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 2 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6492..6500

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 79.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                init: function (words, sigBytes) {
                                                                                                                                    words = this.words = words || [];
                                                                                                                    
                                                                                                                                    if (sigBytes != undefined) {
                                                                                                                                        this.sigBytes = sigBytes;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 2 hrs to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1278..1286

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 79.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                                t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 125..125

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 70.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                                t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 119..119

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 70.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        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++];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 188..188

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 69.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        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++];
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 187..187

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 69.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    for (var i = 0; i < 5; i++) {
                                                                                                                                        // Shortcut
                                                                                                                                        var H_i = H[i];
                                                                                                                    
                                                                                                                                        // Swap
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2363..2370

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 68.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
                                                                                                                                        (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
                                                                                                                                        (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
                                                                                                                                    );
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 3 other locations - About 1 hr to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2353..2356
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2723..2726
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4217..4220

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 63.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
                                                                                                                                        (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
                                                                                                                                        (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
                                                                                                                                    );
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 3 other locations - About 1 hr to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2353..2356
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2719..2722
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4217..4220

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 63.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
                                                                                                                                        (((nBitsTotal << 8)  | (nBitsTotal >>> 24)) & 0x00ff00ff) |
                                                                                                                                        (((nBitsTotal << 24) | (nBitsTotal >>> 8))  & 0xff00ff00)
                                                                                                                                    );
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 3 other locations - About 1 hr to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2353..2356
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2719..2722
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2723..2726

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 63.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                decryptBlock: function (M, offset) {
                                                                                                                                    this._des3.decryptBlock(M, offset);
                                                                                                                                    this._des2.encryptBlock(M, offset);
                                                                                                                                    this._des1.decryptBlock(M, offset);
                                                                                                                                },
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6218..6222

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 60.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                encryptBlock: function (M, offset) {
                                                                                                                                    this._des1.encryptBlock(M, offset);
                                                                                                                                    this._des2.decryptBlock(M, offset);
                                                                                                                                    this._des3.encryptBlock(M, offset);
                                                                                                                                },
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6224..6228

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 60.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            unpad: function (data) {
                                                                                                                                // Get number of padding bytes from last byte
                                                                                                                                var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
                                                                                                                    
                                                                                                                                // Remove padding
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3203..3209

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 59.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            unpad: function (data) {
                                                                                                                                // Get number of padding bytes from last byte
                                                                                                                                var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
                                                                                                                    
                                                                                                                                // Remove padding
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3248..3254

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 59.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    for (var i = 0; i < sigBytes; i++) {
                                                                                                                                        var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                                                                                                                                        latin1Chars.push(String.fromCharCode(bite));
                                                                                                                                    }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2022..2025

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 58.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    for (var i = 0; i < sigBytes; i += 2) {
                                                                                                                                        var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
                                                                                                                                        utf16Chars.push(String.fromCharCode(codePoint));
                                                                                                                                    }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1512..1515

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 58.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            function exchangeRL(offset, mask) {
                                                                                                                                var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;
                                                                                                                                this._lBlock ^= t;
                                                                                                                                this._rBlock ^= t << offset;
                                                                                                                            }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6181..6185

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 57.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            function exchangeLR(offset, mask) {
                                                                                                                                var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;
                                                                                                                                this._rBlock ^= t;
                                                                                                                                this._lBlock ^= t << offset;
                                                                                                                            }
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 1 hr to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 6187..6191

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 57.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                clone: function () {
                                                                                                                                    var clone = Hasher.clone.call(this);
                                                                                                                                    clone._hash = this._hash.clone();
                                                                                                                    
                                                                                                                                    return clone;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2750..2755
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4244..4249
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4704..4709
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5434..5439

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                clone: function () {
                                                                                                                                    var clone = Hasher.clone.call(this);
                                                                                                                                    clone._hash = this._hash.clone();
                                                                                                                    
                                                                                                                                    return clone;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2750..2755
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4244..4249
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4423..4428
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5434..5439

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                clone: function () {
                                                                                                                                    var clone = Hasher.clone.call(this);
                                                                                                                                    clone._hash = this._hash.clone();
                                                                                                                    
                                                                                                                                    return clone;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2750..2755
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4423..4428
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4704..4709
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5434..5439

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                clone: function () {
                                                                                                                                    var clone = Hasher.clone.call(this);
                                                                                                                                    clone._hash = this._hash.clone();
                                                                                                                    
                                                                                                                                    return clone;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4244..4249
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4423..4428
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4704..4709
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5434..5439

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                clone: function () {
                                                                                                                                    var clone = Hasher.clone.call(this);
                                                                                                                                    clone._hash = this._hash.clone();
                                                                                                                    
                                                                                                                                    return clone;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2750..2755
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4244..4249
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4423..4428
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4704..4709

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                finalize: function (messageUpdate) {
                                                                                                                                    // Final message update
                                                                                                                                    if (messageUpdate) {
                                                                                                                                        this._append(messageUpdate);
                                                                                                                                    }
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 385..395

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                finalize: function (dataUpdate) {
                                                                                                                                    // Final data update
                                                                                                                                    if (dataUpdate) {
                                                                                                                                        this._append(dataUpdate);
                                                                                                                                    }
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1786..1796

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 54.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                            var gamma0l  = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5322..5322
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5352..5352

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 53.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                            var gamma1l  = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5315..5315
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5352..5352

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 53.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 55 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5315..5315
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5322..5322

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 53.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        var sigma0h = ((ah >>> 28) | (al << 4))  ^ ((ah << 30)  | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 50 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4656..4656
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4657..4657
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5350..5350
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5351..5351

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 51.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        var sigma0l = ((al >>> 28) | (ah << 4))  ^ ((al << 30)  | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 50 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4656..4656
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4657..4657
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5349..5349
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5351..5351

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 51.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 50 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4657..4657
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5349..5349
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5350..5350
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5351..5351

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 51.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 50 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4656..4656
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5349..5349
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5350..5350
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5351..5351

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 51.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 4 other locations - About 50 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4656..4656
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4657..4657
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5349..5349
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5350..5350

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 51.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    for (var i = 0; i < 8; i++) {
                                                                                                                                        C[i] ^= X[(i + 4) & 7];
                                                                                                                                    }
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 45 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3784..3786

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 50.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    for (var i = 0; i < 8; i++) {
                                                                                                                                        C[i] ^= X[(i + 4) & 7];
                                                                                                                                    }
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 45 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3591..3593

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 50.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            ECB.Decryptor = ECB.extend({
                                                                                                                                processBlock: function (words, offset) {
                                                                                                                                    this._cipher.decryptBlock(words, offset);
                                                                                                                                }
                                                                                                                            });
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 40 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3092..3096

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 48.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                            ECB.Encryptor = ECB.extend({
                                                                                                                                processBlock: function (words, offset) {
                                                                                                                                    this._cipher.encryptBlock(words, offset);
                                                                                                                                }
                                                                                                                            });
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 40 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3098..3102

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 48.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
                                                                                                                                               (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 35 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2598..2601

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 47.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    if (iv) {
                                                                                                                                        counter = this._counter = iv.slice(0);
                                                                                                                    
                                                                                                                                        // Remove IV for subsequent blocks
                                                                                                                                        this._iv = undefined;
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 35 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3042..3047
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3142..3147

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 47.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    if (iv) {
                                                                                                                                        counter = this._counter = iv.slice(0);
                                                                                                                    
                                                                                                                                        // Remove IV for subsequent blocks
                                                                                                                                        this._iv = undefined;
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 35 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2981..2986
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3142..3147

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 47.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                    if (iv) {
                                                                                                                                        keystream = this._keystream = iv.slice(0);
                                                                                                                    
                                                                                                                                        // Remove IV for subsequent blocks
                                                                                                                                        this._iv = undefined;
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 2 other locations - About 35 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2981..2986
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 3042..3047

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 47.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        M[offset_i] = (
                                                                                                                                            (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
                                                                                                                                            (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
                                                                                                                                        );
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 35 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2742..2743

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 47.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        laneMsw = (
                                                                                                                                            (((laneMsw << 8)  | (laneMsw >>> 24)) & 0x00ff00ff) |
                                                                                                                                            (((laneMsw << 24) | (laneMsw >>> 8))  & 0xff00ff00)
                                                                                                                                        );
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 30 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4874..4877

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 45.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        laneLsw = (
                                                                                                                                            (((laneLsw << 8)  | (laneLsw >>> 24)) & 0x00ff00ff) |
                                                                                                                                            (((laneLsw << 24) | (laneLsw >>> 8))  & 0xff00ff00)
                                                                                                                                        );
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 30 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4878..4881

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 45.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        M2i = (
                                                                                                                                            (((M2i << 8)  | (M2i >>> 24)) & 0x00ff00ff) |
                                                                                                                                            (((M2i << 24) | (M2i >>> 8))  & 0xff00ff00)
                                                                                                                                        );
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 30 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5006..5009

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 45.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                            var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 30 mins to fix
                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2536..2536

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 45.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                    Open

                                                                                                                                        M2i1 = (
                                                                                                                                            (((M2i1 << 8)  | (M2i1 >>> 24)) & 0x00ff00ff) |
                                                                                                                                            (((M2i1 << 24) | (M2i1 >>> 8))  & 0xff00ff00)
                                                                                                                                        );
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/crypto-js/cryptojs.js and 1 other location - About 30 mins to fix
                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 5010..5013

                                                                                                                    Duplicated Code

                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 45.

                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                    Refactorings

                                                                                                                    Further Reading

                                                                                                                    There are no issues that match your filters.

                                                                                                                    Category
                                                                                                                    Status