codenautas/txt-to-sql

View on GitHub
web/iconv-lite.js

Summary

Maintainability
F
6 mos
Test Coverage

Function 3 has a Cognitive Complexity of 734 (exceeds 5 allowed). Consider refactoring.
Open

},{}],3:[function(require,module,exports){
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
Severity: Minor
Found in web/iconv-lite.js - About 2 wks to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

File iconv-lite.js has 4936 lines of code (exceeds 250 allowed). Consider refactoring.
Open

require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
'use strict'

exports.byteLength = byteLength
exports.toByteArray = toByteArray
Severity: Major
Found in web/iconv-lite.js - About 2 wks to fix

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

    },{}],3:[function(require,module,exports){
    /*!
     * The buffer module from node.js, for the browser.
     *
     * @author   Feross Aboukhadijeh <https://feross.org>
    Severity: Major
    Found in web/iconv-lite.js - About 6 days to fix

      Function 4 has a Cognitive Complexity of 252 (exceeds 5 allowed). Consider refactoring.
      Open

      },{"base64-js":1,"ieee754":22}],4:[function(require,module,exports){
      "use strict";
      var Buffer = require("safer-buffer").Buffer;
      
      // Multibyte codec. In this scheme, a character is represented by 1 or more bytes.
      Severity: Minor
      Found in web/iconv-lite.js - About 5 days to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function 26 has a Cognitive Complexity of 113 (exceeds 5 allowed). Consider refactoring.
      Open

      },{"_process":23,"buffer":3}],26:[function(require,module,exports){
      'use strict';
      
      var Buffer = require('safe-buffer').Buffer;
      
      
      Severity: Minor
      Found in web/iconv-lite.js - About 2 days to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

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

      },{"safer-buffer":25}],9:[function(require,module,exports){
      "use strict";
      
      // Generated data for sbcs codec. Don't edit manually. Regenerate using generation/gen-sbcs.js script.
      module.exports = {
      Severity: Major
      Found in web/iconv-lite.js - About 2 days to fix

        Function 20 has a Cognitive Complexity of 106 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"safer-buffer":25}],20:[function(require,module,exports){
        "use strict";
        var Buffer = require("safer-buffer").Buffer;
        
        // UTF-7 codec, according to https://tools.ietf.org/html/rfc2152
        Severity: Minor
        Found in web/iconv-lite.js - About 2 days to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

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

        },{"base64-js":1,"ieee754":22}],4:[function(require,module,exports){
        "use strict";
        var Buffer = require("safer-buffer").Buffer;
        
        // Multibyte codec. In this scheme, a character is represented by 1 or more bytes.
        Severity: Major
        Found in web/iconv-lite.js - About 1 day to fix

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

          },{}],13:[function(require,module,exports){
          module.exports=[
          ["0","\u0000",127],
          ["8141","갂갃갅갆갋",4,"갘갞갟갡갢갣갥",6,"갮갲갳갴"],
          ["8161","갵갶갷갺갻갽갾갿걁",9,"걌걎",5,"걕"],
          Severity: Major
          Found in web/iconv-lite.js - About 1 day to fix

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

            },{}],12:[function(require,module,exports){
            module.exports=[
            ["0","\u0000",127,"€"],
            ["8140","丂丄丅丆丏丒丗丟丠両丣並丩丮丯丱丳丵丷丼乀乁乂乄乆乊乑乕乗乚乛乢乣乤乥乧乨乪",5,"乲乴",9,"乿",6,"亇亊"],
            ["8180","亐亖亗亙亜亝亞亣亪亯亰亱亴亶亷亸亹亼亽亾仈仌仏仐仒仚仛仜仠仢仦仧仩仭仮仯仱仴仸仹仺仼仾伀伂",6,"伋伌伒",4,"伜伝伡伣伨伩伬伭伮伱伳伵伷伹伻伾",4,"佄佅佇",5,"佒佔佖佡佢佦佨佪佫佭佮佱佲併佷佸佹佺佽侀侁侂侅來侇侊侌侎侐侒侓侕侖侘侙侚侜侞侟価侢"],
            Severity: Major
            Found in web/iconv-lite.js - About 1 day to fix

              Function iconv-lite has a Cognitive Complexity of 63 (exceeds 5 allowed). Consider refactoring.
              Open

              },{"safe-buffer":24}],"iconv-lite":[function(require,module,exports){
              (function (process){
              "use strict";
              
              // Some environments don't have global Buffer (e.g. React Native).
              Severity: Minor
              Found in web/iconv-lite.js - About 1 day to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function 22 has a Cognitive Complexity of 56 (exceeds 5 allowed). Consider refactoring.
              Open

              },{}],22:[function(require,module,exports){
              exports.read = function (buffer, offset, isLE, mLen, nBytes) {
                var e, m
                var eLen = (nBytes * 8) - mLen - 1
                var eMax = (1 << eLen) - 1
              Severity: Minor
              Found in web/iconv-lite.js - About 1 day to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

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

              },{"_process":23,"buffer":3}],26:[function(require,module,exports){
              'use strict';
              
              var Buffer = require('safe-buffer').Buffer;
              
              
              Severity: Major
              Found in web/iconv-lite.js - About 1 day to fix

                Function 25 has a Cognitive Complexity of 55 (exceeds 5 allowed). Consider refactoring.
                Open

                },{"buffer":3}],25:[function(require,module,exports){
                (function (process){
                /* eslint-disable node/no-deprecated-api */
                
                'use strict'
                Severity: Minor
                Found in web/iconv-lite.js - About 1 day to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

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

                },{"safer-buffer":25}],20:[function(require,module,exports){
                "use strict";
                var Buffer = require("safer-buffer").Buffer;
                
                // UTF-7 codec, according to https://tools.ietf.org/html/rfc2152
                Severity: Major
                Found in web/iconv-lite.js - About 1 day to fix

                  Function 19 has a Cognitive Complexity of 50 (exceeds 5 allowed). Consider refactoring.
                  Open

                  },{}],19:[function(require,module,exports){
                  "use strict";
                  var Buffer = require("safer-buffer").Buffer;
                  
                  // Note: UTF16-LE (or UCS2) codec is Node.js native. See encodings/internal.js
                  Severity: Minor
                  Found in web/iconv-lite.js - About 7 hrs to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Function 7 has a Cognitive Complexity of 50 (exceeds 5 allowed). Consider refactoring.
                  Open

                  },{"./dbcs-codec":4,"./dbcs-data":5,"./internal":7,"./sbcs-codec":8,"./sbcs-data":10,"./sbcs-data-generated":9,"./utf16":19,"./utf7":20}],7:[function(require,module,exports){
                  "use strict";
                  var Buffer = require("safer-buffer").Buffer;
                  
                  // Export Node.js internal encodings.
                  Severity: Minor
                  Found in web/iconv-lite.js - About 7 hrs to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Function 23 has a Cognitive Complexity of 48 (exceeds 5 allowed). Consider refactoring.
                  Open

                  },{}],23:[function(require,module,exports){
                  // shim for using process in browser
                  var process = module.exports = {};
                  
                  // cached from whatever global is present so that test runners that stub it
                  Severity: Minor
                  Found in web/iconv-lite.js - About 7 hrs to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

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

                  },{}],15:[function(require,module,exports){
                  module.exports=[
                  ["0","\u0000",127],
                  ["8ea1","。",62],
                  ["a1a1"," 、。,.・:;?!゛゜´`¨^ ̄_ヽヾゝゞ〃仝々〆〇ー―‐/\~∥|…‥‘’“”()〔〕[]{}〈",9,"+-±×÷=≠<>≦≧∞∴♂♀°′″℃¥$¢£%#&*@§☆★○●◎◇"],
                  Severity: Major
                  Found in web/iconv-lite.js - About 7 hrs to fix

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

                    },{}],14:[function(require,module,exports){
                    module.exports=[
                    ["0","\u0000",127],
                    ["a140"," ,、。.‧;:?!︰…‥﹐﹑﹒·﹔﹕﹖﹗|–︱—︳╴︴﹏()︵︶{}︷︸〔〕︹︺【】︻︼《》︽︾〈〉︿﹀「」﹁﹂『』﹃﹄﹙﹚"],
                    ["a1a1","﹛﹜﹝﹞‘’“”〝〞‵′#&*※§〃○●△▲◎☆★◇◆□■▽▼㊣℅¯ ̄_ˍ﹉﹊﹍﹎﹋﹌﹟﹠﹡+-×÷±√<>=≦≧≠∞≒≡﹢",4,"~∩∪⊥∠∟⊿㏒㏑∫∮∵∴♀♂⊕⊙↑↓←→↖↗↙↘∥∣/"],
                    Severity: Major
                    Found in web/iconv-lite.js - About 7 hrs to fix

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

                      },{}],23:[function(require,module,exports){
                      // shim for using process in browser
                      var process = module.exports = {};
                      
                      // cached from whatever global is present so that test runners that stub it
                      Severity: Major
                      Found in web/iconv-lite.js - About 5 hrs to fix

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

                        },{}],10:[function(require,module,exports){
                        "use strict";
                        
                        // Manually added data to be used by sbcs codec in addition to generated one.
                        
                        
                        Severity: Major
                        Found in web/iconv-lite.js - About 5 hrs to fix

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

                          },{"./dbcs-codec":4,"./dbcs-data":5,"./internal":7,"./sbcs-codec":8,"./sbcs-data":10,"./sbcs-data-generated":9,"./utf16":19,"./utf7":20}],7:[function(require,module,exports){
                          "use strict";
                          var Buffer = require("safer-buffer").Buffer;
                          
                          // Export Node.js internal encodings.
                          Severity: Major
                          Found in web/iconv-lite.js - About 5 hrs to fix

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

                            },{}],18:[function(require,module,exports){
                            module.exports=[
                            ["0","\u0000",128],
                            ["a1","。",62],
                            ["8140"," 、。,.・:;?!゛゜´`¨^ ̄_ヽヾゝゞ〃仝々〆〇ー―‐/\~∥|…‥‘’“”()〔〕[]{}〈",9,"+-±×"],
                            Severity: Major
                            Found in web/iconv-lite.js - About 5 hrs to fix

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

                              },{}],11:[function(require,module,exports){
                              module.exports=[
                              ["8740","䏰䰲䘃䖦䕸𧉧䵷䖳𧲱䳢𧳅㮕䜶䝄䱇䱀𤊿𣘗𧍒𦺋𧃒䱗𪍑䝏䗚䲅𧱬䴇䪤䚡𦬣爥𥩔𡩣𣸆𣽡晍囻"],
                              ["8767","綕夝𨮹㷴霴𧯯寛𡵞媤㘥𩺰嫑宷峼杮薓𩥅瑡璝㡵𡵓𣚞𦀡㻬"],
                              ["87a1","𥣞㫵竼龗𤅡𨤍𣇪𠪊𣉞䌊蒄龖鐯䤰蘓墖靊鈘秐稲晠権袝瑌篅枂稬剏遆㓦珄𥶹瓆鿇垳䤯呌䄱𣚎堘穲𧭥讏䚮𦺈䆁𥶙箮𢒼鿈𢓁𢓉𢓌鿉蔄𣖻䂴鿊䓡𪷿拁灮鿋"],
                              Severity: Major
                              Found in web/iconv-lite.js - About 4 hrs to fix

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

                                require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
                                'use strict'
                                
                                exports.byteLength = byteLength
                                exports.toByteArray = toByteArray
                                Severity: Major
                                Found in web/iconv-lite.js - About 4 hrs to fix

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

                                  },{}],19:[function(require,module,exports){
                                  "use strict";
                                  var Buffer = require("safer-buffer").Buffer;
                                  
                                  // Note: UTF16-LE (or UCS2) codec is Node.js native. See encodings/internal.js
                                  Severity: Major
                                  Found in web/iconv-lite.js - About 4 hrs to fix

                                    Function iconv-lite has 100 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                    },{"safe-buffer":24}],"iconv-lite":[function(require,module,exports){
                                    (function (process){
                                    "use strict";
                                    
                                    // Some environments don't have global Buffer (e.g. React Native).
                                    Severity: Major
                                    Found in web/iconv-lite.js - About 4 hrs to fix

                                      Function 1 has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
                                      Open

                                      require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
                                      'use strict'
                                      
                                      exports.byteLength = byteLength
                                      exports.toByteArray = toByteArray
                                      Severity: Minor
                                      Found in web/iconv-lite.js - About 3 hrs to fix

                                      Cognitive Complexity

                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                      A method's cognitive complexity is based on a few simple rules:

                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                      • Code is considered more complex for each "break in the linear flow of the code"
                                      • Code is considered more complex when "flow breaking structures are nested"

                                      Further reading

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

                                      DBCSEncoder.prototype.write = function(str) {
                                          var newBuf = Buffer.alloc(str.length * (this.gb18030 ? 4 : 3)),
                                              leadSurrogate = this.leadSurrogate,
                                              seqObj = this.seqObj, nextChar = -1,
                                              i = 0, j = 0;
                                      Severity: Major
                                      Found in web/iconv-lite.js - About 3 hrs to fix

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

                                        },{"safer-buffer":25}],5:[function(require,module,exports){
                                        "use strict";
                                        
                                        // Description of supported double byte encodings and aliases.
                                        // Tables are not require()-d until they are needed to speed up library load.
                                        Severity: Major
                                        Found in web/iconv-lite.js - About 3 hrs to fix

                                          `` has 27 functions (exceeds 20 allowed). Consider refactoring.
                                          Open

                                          require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
                                          'use strict'
                                          
                                          exports.byteLength = byteLength
                                          exports.toByteArray = toByteArray
                                          Severity: Minor
                                          Found in web/iconv-lite.js - About 3 hrs to fix

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

                                            },{}],22:[function(require,module,exports){
                                            exports.read = function (buffer, offset, isLE, mLen, nBytes) {
                                              var e, m
                                              var eLen = (nBytes * 8) - mLen - 1
                                              var eMax = (1 << eLen) - 1
                                            Severity: Major
                                            Found in web/iconv-lite.js - About 2 hrs to fix

                                              Function 24 has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
                                              Open

                                              },{}],24:[function(require,module,exports){
                                              /* eslint-disable node/no-deprecated-api */
                                              var buffer = require('buffer')
                                              var Buffer = buffer.Buffer
                                              
                                              
                                              Severity: Minor
                                              Found in web/iconv-lite.js - About 2 hrs to fix

                                              Cognitive Complexity

                                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                              A method's cognitive complexity is based on a few simple rules:

                                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                              • Code is considered more complex for each "break in the linear flow of the code"
                                              • Code is considered more complex when "flow breaking structures are nested"

                                              Further reading

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

                                              },{"buffer":3}],25:[function(require,module,exports){
                                              (function (process){
                                              /* eslint-disable node/no-deprecated-api */
                                              
                                              'use strict'
                                              Severity: Major
                                              Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                function utf8Slice (buf, start, end) {
                                                  end = Math.min(buf.length, end)
                                                  var res = []
                                                
                                                  var i = start
                                                Severity: Major
                                                Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                  function utf8ToBytes (string, units) {
                                                    units = units || Infinity
                                                    var codePoint
                                                    var length = string.length
                                                    var leadSurrogate = null
                                                  Severity: Major
                                                  Found in web/iconv-lite.js - About 2 hrs to fix

                                                    Function 8 has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                                                    Open

                                                    },{"safer-buffer":25,"string_decoder":26}],8:[function(require,module,exports){
                                                    "use strict";
                                                    var Buffer = require("safer-buffer").Buffer;
                                                    
                                                    // Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that
                                                    Severity: Minor
                                                    Found in web/iconv-lite.js - About 2 hrs to fix

                                                    Cognitive Complexity

                                                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                    A method's cognitive complexity is based on a few simple rules:

                                                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                    • Code is considered more complex for each "break in the linear flow of the code"
                                                    • Code is considered more complex when "flow breaking structures are nested"

                                                    Further reading

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

                                                    },{}],17:[function(require,module,exports){
                                                    module.exports=[
                                                    ["a140","",62],
                                                    ["a180","",32],
                                                    ["a240","",62],
                                                    Severity: Major
                                                    Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                      Buffer.prototype.write = function write (string, offset, length, encoding) {
                                                        // Buffer#write(string)
                                                        if (offset === undefined) {
                                                          encoding = 'utf8'
                                                          length = this.length
                                                      Severity: Major
                                                      Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                        DBCSDecoder.prototype.write = function(buf) {
                                                            var newBuf = Buffer.alloc(buf.length*2),
                                                                nodeIdx = this.nodeIdx, 
                                                                prevBuf = this.prevBuf, prevBufOffset = this.prevBuf.length,
                                                                seqStart = -this.prevBuf.length, // idx of the start of current parsed sequence.
                                                        Severity: Major
                                                        Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                          },{}],24:[function(require,module,exports){
                                                          /* eslint-disable node/no-deprecated-api */
                                                          var buffer = require('buffer')
                                                          var Buffer = buffer.Buffer
                                                          
                                                          
                                                          Severity: Major
                                                          Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                            function DBCSCodec(codecOptions, iconv) {
                                                                this.encodingName = codecOptions.encodingName;
                                                                if (!codecOptions)
                                                                    throw new Error("DBCS codec is called without the data.")
                                                                if (!codecOptions.table)
                                                            Severity: Minor
                                                            Found in web/iconv-lite.js - About 2 hrs to fix

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

                                                              function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
                                                                var indexSize = 1
                                                                var arrLength = arr.length
                                                                var valLength = val.length
                                                              
                                                              
                                                              Severity: Minor
                                                              Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                },{"safer-buffer":25,"string_decoder":26}],8:[function(require,module,exports){
                                                                "use strict";
                                                                var Buffer = require("safer-buffer").Buffer;
                                                                
                                                                // Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that
                                                                Severity: Minor
                                                                Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                  Buffer.prototype.fill = function fill (val, start, end, encoding) {
                                                                    // Handle string cases:
                                                                    if (typeof val === 'string') {
                                                                      if (typeof start === 'string') {
                                                                        encoding = start
                                                                  Severity: Minor
                                                                  Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                    Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
                                                                      if (!Buffer.isBuffer(target)) {
                                                                        throw new TypeError('Argument must be a Buffer')
                                                                      }
                                                                    
                                                                    
                                                                    Severity: Minor
                                                                    Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                      function slowToString (encoding, start, end) {
                                                                        var loweredCase = false
                                                                      
                                                                        // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
                                                                        // property of a typed array.
                                                                      Severity: Minor
                                                                      Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                        exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
                                                                          var e, m, c
                                                                          var eLen = (nBytes * 8) - mLen - 1
                                                                          var eMax = (1 << eLen) - 1
                                                                          var eBias = eMax >> 1
                                                                        Severity: Minor
                                                                        Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                          function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
                                                                            // Empty buffer means no match
                                                                            if (buffer.length === 0) return -1
                                                                          
                                                                            // Normalize byteOffset
                                                                          Severity: Minor
                                                                          Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                            InternalDecoderCesu8.prototype.write = function(buf) {
                                                                                var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, 
                                                                                    res = '';
                                                                                for (var i = 0; i < buf.length; i++) {
                                                                                    var curByte = buf[i];
                                                                            Severity: Minor
                                                                            Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                              Utf7Decoder.prototype.write = function(buf) {
                                                                                  var res = "", lastI = 0,
                                                                                      inBase64 = this.inBase64,
                                                                                      base64Accum = this.base64Accum;
                                                                              
                                                                              
                                                                              Severity: Minor
                                                                              Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                Utf7IMAPDecoder.prototype.write = function(buf) {
                                                                                    var res = "", lastI = 0,
                                                                                        inBase64 = this.inBase64,
                                                                                        base64Accum = this.base64Accum;
                                                                                
                                                                                
                                                                                Severity: Minor
                                                                                Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                  Utf7IMAPEncoder.prototype.write = function(str) {
                                                                                      var inBase64 = this.inBase64,
                                                                                          base64Accum = this.base64Accum,
                                                                                          base64AccumIdx = this.base64AccumIdx,
                                                                                          buf = Buffer.alloc(str.length*5 + 10), bufIdx = 0;
                                                                                  Severity: Minor
                                                                                  Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                    DBCSCodec.prototype._addDecodeChunk = function(chunk) {
                                                                                        // First element of chunk is the hex mbcs code where we start.
                                                                                        var curAddr = parseInt(chunk[0], 16);
                                                                                    
                                                                                        // Choose the decoding node where we'll write our chars.
                                                                                    Severity: Minor
                                                                                    Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                      },{"safer-buffer":25}],21:[function(require,module,exports){
                                                                                      "use strict";
                                                                                      
                                                                                      var BOMChar = '\uFEFF';
                                                                                      
                                                                                      
                                                                                      Severity: Minor
                                                                                      Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                        function byteLength (string, encoding) {
                                                                                          if (Buffer.isBuffer(string)) {
                                                                                            return string.length
                                                                                          }
                                                                                          if (isArrayBufferView(string) || isArrayBuffer(string)) {
                                                                                        Severity: Minor
                                                                                        Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                          Buffer.prototype.copy = function copy (target, targetStart, start, end) {
                                                                                            if (!start) start = 0
                                                                                            if (!end && end !== 0) end = this.length
                                                                                            if (targetStart >= target.length) targetStart = target.length
                                                                                            if (!targetStart) targetStart = 0
                                                                                          Severity: Minor
                                                                                          Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                            function toByteArray (b64) {
                                                                                              var tmp
                                                                                              var lens = getLens(b64)
                                                                                              var validLen = lens[0]
                                                                                              var placeHoldersLen = lens[1]
                                                                                            Severity: Minor
                                                                                            Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                              iconv.getCodec = function getCodec(encoding) {
                                                                                                  if (!iconv.encodings)
                                                                                                      iconv.encodings = require("../encodings"); // Lazy load all encoding definitions.
                                                                                                  
                                                                                                  // Canonicalize encoding name: strip all non-alphanumeric chars and appended year.
                                                                                              Severity: Minor
                                                                                              Found in web/iconv-lite.js - About 1 hr to fix

                                                                                                Function 21 has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                                                                                                Open

                                                                                                },{"safer-buffer":25}],21:[function(require,module,exports){
                                                                                                "use strict";
                                                                                                
                                                                                                var BOMChar = '\uFEFF';
                                                                                                
                                                                                                
                                                                                                Severity: Minor
                                                                                                Found in web/iconv-lite.js - About 1 hr to fix

                                                                                                Cognitive Complexity

                                                                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                A method's cognitive complexity is based on a few simple rules:

                                                                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                • Code is considered more complex when "flow breaking structures are nested"

                                                                                                Further reading

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

                                                                                                function fromByteArray (uint8) {
                                                                                                  var tmp
                                                                                                  var len = uint8.length
                                                                                                  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
                                                                                                  var parts = []
                                                                                                Severity: Minor
                                                                                                Found in web/iconv-lite.js - About 1 hr to fix

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

                                                                                                  exports.read = function (buffer, offset, isLE, mLen, nBytes) {
                                                                                                    var e, m
                                                                                                    var eLen = (nBytes * 8) - mLen - 1
                                                                                                    var eMax = (1 << eLen) - 1
                                                                                                    var eBias = eMax >> 1
                                                                                                  Severity: Minor
                                                                                                  Found in web/iconv-lite.js - About 1 hr to fix

                                                                                                    Function checkInt has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                    function checkInt (buf, value, offset, ext, max, min) {
                                                                                                    Severity: Minor
                                                                                                    Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                      Function checkIEEE754 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                      function checkIEEE754 (buf, value, offset, ext, max, min) {
                                                                                                      Severity: Minor
                                                                                                      Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                        Function write has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                        Open

                                                                                                        exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
                                                                                                        Severity: Minor
                                                                                                        Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                if ((units -= 3) < 0) break
                                                                                                          Severity: Major
                                                                                                          Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                            Avoid deeply nested control flow statements.
                                                                                                            Open

                                                                                                                        if (tempCodePoint > 0x7F) {
                                                                                                                          codePoint = tempCodePoint
                                                                                                                        }
                                                                                                            Severity: Major
                                                                                                            Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                              Avoid deeply nested control flow statements.
                                                                                                              Open

                                                                                                                              if (idx != -1) {
                                                                                                                                  var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);
                                                                                                                                  newBuf[j++] = 0x81 + Math.floor(dbcsCode / 12600); dbcsCode = dbcsCode % 12600;
                                                                                                                                  newBuf[j++] = 0x30 + Math.floor(dbcsCode / 1260); dbcsCode = dbcsCode % 1260;
                                                                                                                                  newBuf[j++] = 0x81 + Math.floor(dbcsCode / 10); dbcsCode = dbcsCode % 10;
                                                                                                              Severity: Major
                                                                                                              Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                Open

                                                                                                                          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                                                                                                                Severity: Major
                                                                                                                Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                  Open

                                                                                                                                      if (0xDC00 <= codeTrail && codeTrail < 0xE000)
                                                                                                                                          writeTable[curAddr++] = 0x10000 + (code - 0xD800) * 0x400 + (codeTrail - 0xDC00);
                                                                                                                                      else
                                                                                                                                          throw new Error("Incorrect surrogate pair in "  + this.encodingName + " at chunk " + chunk[0]);
                                                                                                                  Severity: Major
                                                                                                                  Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                    Open

                                                                                                                                if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                                                                                                                                  codePoint = tempCodePoint
                                                                                                                                }
                                                                                                                    Severity: Major
                                                                                                                    Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                      Open

                                                                                                                          } else if (codePoint < 0x110000) {
                                                                                                                            if ((units -= 4) < 0) break
                                                                                                                            bytes.push(
                                                                                                                              codePoint >> 0x12 | 0xF0,
                                                                                                                              codePoint >> 0xC & 0x3F | 0x80,
                                                                                                                      Severity: Major
                                                                                                                      Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                        Open

                                                                                                                                } else if (i + 1 === length) {
                                                                                                                                  // unpaired lead
                                                                                                                                  if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                                                                                                                                  continue
                                                                                                                                }
                                                                                                                        Severity: Major
                                                                                                                        Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                          Open

                                                                                                                                          else if (0x0FF0 < code && code <= 0x0FFF) { // Character sequence (our own encoding used)
                                                                                                                                              var len = 0xFFF - code + 2;
                                                                                                                                              var seq = [];
                                                                                                                                              for (var m = 0; m < len; m++)
                                                                                                                                                  seq.push(part.charCodeAt(l++)); // Simple variation: don't support surrogates or subsequences in seq.
                                                                                                                          Severity: Major
                                                                                                                          Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                            Open

                                                                                                                                                if (accBytes === 2 && acc < 0x80 && acc > 0)
                                                                                                                                                    res += this.defaultCharUnicode;
                                                                                                                                                else if (accBytes === 3 && acc < 0x800)
                                                                                                                                                    res += this.defaultCharUnicode;
                                                                                                                                                else
                                                                                                                            Severity: Major
                                                                                                                            Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                              Open

                                                                                                                                          if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                                                                                                                                            codePoint = tempCodePoint
                                                                                                                                          }
                                                                                                                              Severity: Major
                                                                                                                              Found in web/iconv-lite.js - About 45 mins to fix

                                                                                                                                Function writeFloat has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                Open

                                                                                                                                function writeFloat (buf, value, offset, littleEndian, noAssert) {
                                                                                                                                Severity: Minor
                                                                                                                                Found in web/iconv-lite.js - About 35 mins to fix

                                                                                                                                  Function writeDouble has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                  Open

                                                                                                                                  function writeDouble (buf, value, offset, littleEndian, noAssert) {
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in web/iconv-lite.js - About 35 mins to fix

                                                                                                                                    Function arrayIndexOf has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                    Open

                                                                                                                                    function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in web/iconv-lite.js - About 35 mins to fix

                                                                                                                                      Function read has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                      Open

                                                                                                                                      exports.read = function (buffer, offset, isLE, mLen, nBytes) {
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in web/iconv-lite.js - About 35 mins to fix

                                                                                                                                        Function compare has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                        Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in web/iconv-lite.js - About 35 mins to fix

                                                                                                                                          Function bidirectionalIndexOf has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                          Open

                                                                                                                                          function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in web/iconv-lite.js - About 35 mins to fix

                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                            Open

                                                                                                                                                return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
                                                                                                                                            Severity: Major
                                                                                                                                            Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                              Open

                                                                                                                                                return 0
                                                                                                                                              Severity: Major
                                                                                                                                              Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                Open

                                                                                                                                                        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
                                                                                                                                                Severity: Major
                                                                                                                                                Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                  Open

                                                                                                                                                              return cachedSetTimeout.call(this, fun, 0);
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                    Open

                                                                                                                                                      return -1;
                                                                                                                                                    Severity: Major
                                                                                                                                                    Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                      Open

                                                                                                                                                        if (x < y) return -1
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                        Open

                                                                                                                                                          if (--j < i) return 0;
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                          Open

                                                                                                                                                              return nb;
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                            Open

                                                                                                                                                                    return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                              Open

                                                                                                                                                                  return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                Open

                                                                                                                                                                  if (y < x) return 1
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                  Open

                                                                                                                                                                        return fromArrayLike(obj.data)
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                    Open

                                                                                                                                                                                return cachedClearTimeout.call(this, marker);
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                      Open

                                                                                                                                                                        return 0;
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in web/iconv-lite.js - About 30 mins to fix

                                                                                                                                                                        Function 6 has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                        },{"./tables/big5-added.json":11,"./tables/cp936.json":12,"./tables/cp949.json":13,"./tables/cp950.json":14,"./tables/eucjp.json":15,"./tables/gb18030-ranges.json":16,"./tables/gbk-added.json":17,"./tables/shiftjis.json":18}],6:[function(require,module,exports){
                                                                                                                                                                        "use strict";
                                                                                                                                                                        
                                                                                                                                                                        // Update this array if you add/rename/remove files in this directory.
                                                                                                                                                                        // We support Browserify by skipping automatic module discovery and requiring modules directly.
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js - About 25 mins to fix

                                                                                                                                                                        Cognitive Complexity

                                                                                                                                                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                                                                        A method's cognitive complexity is based on a few simple rules:

                                                                                                                                                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                                                                        • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                                                                        • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                                                                        Further reading

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

                                                                                                                                                                        },{}],3:[function(require,module,exports){
                                                                                                                                                                        /*!
                                                                                                                                                                         * The buffer module from node.js, for the browser.
                                                                                                                                                                         *
                                                                                                                                                                         * @author   Feross Aboukhadijeh <https://feross.org>
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 3 mos to fix
                                                                                                                                                                        web/buffer.js on lines 240..1956

                                                                                                                                                                        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 13926.

                                                                                                                                                                        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 2 locations. Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                        require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
                                                                                                                                                                        'use strict'
                                                                                                                                                                        
                                                                                                                                                                        exports.byteLength = byteLength
                                                                                                                                                                        exports.toByteArray = toByteArray
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 1 wk to fix
                                                                                                                                                                        web/buffer.js on lines 1..154

                                                                                                                                                                        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 1382.

                                                                                                                                                                        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

                                                                                                                                                                        },{}],22:[function(require,module,exports){
                                                                                                                                                                        exports.read = function (buffer, offset, isLE, mLen, nBytes) {
                                                                                                                                                                          var e, m
                                                                                                                                                                          var eLen = (nBytes * 8) - mLen - 1
                                                                                                                                                                          var eMax = (1 << eLen) - 1
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 6 days to fix
                                                                                                                                                                        web/buffer.js on lines 154..240

                                                                                                                                                                        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 1115.

                                                                                                                                                                        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

                                                                                                                                                                        module.exports={"uChars":[128,165,169,178,184,216,226,235,238,244,248,251,253,258,276,284,300,325,329,334,364,463,465,467,469,471,473,475,477,506,594,610,712,716,730,930,938,962,970,1026,1104,1106,8209,8215,8218,8222,8231,8241,8244,8246,8252,8365,8452,8454,8458,8471,8482,8556,8570,8596,8602,8713,8720,8722,8726,8731,8737,8740,8742,8748,8751,8760,8766,8777,8781,8787,8802,8808,8816,8854,8858,8870,8896,8979,9322,9372,9548,9588,9616,9622,9634,9652,9662,9672,9676,9680,9702,9735,9738,9793,9795,11906,11909,11913,11917,11928,11944,11947,11951,11956,11960,11964,11979,12284,12292,12312,12319,12330,12351,12436,12447,12535,12543,12586,12842,12850,12964,13200,13215,13218,13253,13263,13267,13270,13384,13428,13727,13839,13851,14617,14703,14801,14816,14964,15183,15471,15585,16471,16736,17208,17325,17330,17374,17623,17997,18018,18212,18218,18301,18318,18760,18811,18814,18820,18823,18844,18848,18872,19576,19620,19738,19887,40870,59244,59336,59367,59413,59417,59423,59431,59437,59443,59452,59460,59478,59493,63789,63866,63894,63976,63986,64016,64018,64021,64025,64034,64037,64042,65074,65093,65107,65112,65127,65132,65375,65510,65536],"gbChars":[0,36,38,45,50,81,89,95,96,100,103,104,105,109,126,133,148,172,175,179,208,306,307,308,309,310,311,312,313,341,428,443,544,545,558,741,742,749,750,805,819,820,7922,7924,7925,7927,7934,7943,7944,7945,7950,8062,8148,8149,8152,8164,8174,8236,8240,8262,8264,8374,8380,8381,8384,8388,8390,8392,8393,8394,8396,8401,8406,8416,8419,8424,8437,8439,8445,8482,8485,8496,8521,8603,8936,8946,9046,9050,9063,9066,9076,9092,9100,9108,9111,9113,9131,9162,9164,9218,9219,11329,11331,11334,11336,11346,11361,11363,11366,11370,11372,11375,11389,11682,11686,11687,11692,11694,11714,11716,11723,11725,11730,11736,11982,11989,12102,12336,12348,12350,12384,12393,12395,12397,12510,12553,12851,12962,12973,13738,13823,13919,13933,14080,14298,14585,14698,15583,15847,16318,16434,16438,16481,16729,17102,17122,17315,17320,17402,17418,17859,17909,17911,17915,17916,17936,17939,17961,18664,18703,18814,18962,19043,33469,33470,33471,33484,33485,33490,33497,33501,33505,33513,33520,33536,33550,37845,37921,37948,38029,38038,38064,38065,38066,38069,38075,38076,38078,39108,39109,39113,39114,39115,39116,39265,39394,189000]}
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 1 day to fix
                                                                                                                                                                        web/iconv-lite.js on lines 4547..4547

                                                                                                                                                                        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 213.

                                                                                                                                                                        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

                                                                                                                                                                        Utf7Decoder.prototype.end = function() {
                                                                                                                                                                            var res = "";
                                                                                                                                                                            if (this.inBase64 && this.base64Accum.length > 0)
                                                                                                                                                                                res = this.iconv.decode(Buffer.from(this.base64Accum, 'base64'), "utf16-be");
                                                                                                                                                                        
                                                                                                                                                                        
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5191..5199

                                                                                                                                                                        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 108.

                                                                                                                                                                        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

                                                                                                                                                                        Utf7IMAPDecoder.prototype.end = function() {
                                                                                                                                                                            var res = "";
                                                                                                                                                                            if (this.inBase64 && this.base64Accum.length > 0)
                                                                                                                                                                                res = this.iconv.decode(Buffer.from(this.base64Accum, 'base64'), "utf16-be");
                                                                                                                                                                        
                                                                                                                                                                        
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5020..5028

                                                                                                                                                                        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 108.

                                                                                                                                                                        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 (!inBase64) { // We're in direct mode.
                                                                                                                                                                                    // Write direct chars until '+'
                                                                                                                                                                                    if (buf[i] == plusChar) {
                                                                                                                                                                                        res += this.iconv.decode(buf.slice(lastI, i), "ascii"); // Write direct chars.
                                                                                                                                                                                        lastI = i+1;
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 1 hr to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5147..5170

                                                                                                                                                                        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 73.

                                                                                                                                                                        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 (!inBase64) { // We're in direct mode.
                                                                                                                                                                                    // Write direct chars until '&'
                                                                                                                                                                                    if (buf[i] == andChar) {
                                                                                                                                                                                        res += this.iconv.decode(buf.slice(lastI, i), "ascii"); // Write direct chars.
                                                                                                                                                                                        lastI = i+1;
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 1 hr to fix
                                                                                                                                                                        web/iconv-lite.js on lines 4976..4999

                                                                                                                                                                        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 73.

                                                                                                                                                                        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 (key in buffer) {
                                                                                                                                                                          if (!buffer.hasOwnProperty(key)) continue
                                                                                                                                                                          if (key === 'SlowBuffer' || key === 'Buffer') continue
                                                                                                                                                                          safer[key] = buffer[key]
                                                                                                                                                                        }
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 1 hr to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5613..5617

                                                                                                                                                                        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 56.

                                                                                                                                                                        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 (key in Buffer) {
                                                                                                                                                                          if (!Buffer.hasOwnProperty(key)) continue
                                                                                                                                                                          if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue
                                                                                                                                                                          Safer[key] = Buffer[key]
                                                                                                                                                                        }
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 1 hr to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5606..5610

                                                                                                                                                                        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 56.

                                                                                                                                                                        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

                                                                                                                                                                            try {
                                                                                                                                                                                if (typeof setTimeout === 'function') {
                                                                                                                                                                                    cachedSetTimeout = setTimeout;
                                                                                                                                                                                } else {
                                                                                                                                                                                    cachedSetTimeout = defaultSetTimout;
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 50 mins to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5371..5379

                                                                                                                                                                        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 52.

                                                                                                                                                                        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

                                                                                                                                                                            try {
                                                                                                                                                                                if (typeof clearTimeout === 'function') {
                                                                                                                                                                                    cachedClearTimeout = clearTimeout;
                                                                                                                                                                                } else {
                                                                                                                                                                                    cachedClearTimeout = defaultClearTimeout;
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 50 mins to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5362..5370

                                                                                                                                                                        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 52.

                                                                                                                                                                        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 Utf7IMAPDecoder(options, codec) {
                                                                                                                                                                            this.iconv = codec.iconv;
                                                                                                                                                                            this.inBase64 = false;
                                                                                                                                                                            this.base64Accum = '';
                                                                                                                                                                        }
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 40 mins to fix
                                                                                                                                                                        web/iconv-lite.js on lines 4953..4957

                                                                                                                                                                        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 49.

                                                                                                                                                                        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 Utf7Decoder(options, codec) {
                                                                                                                                                                            this.iconv = codec.iconv;
                                                                                                                                                                            this.inBase64 = false;
                                                                                                                                                                            this.base64Accum = '';
                                                                                                                                                                        }
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 40 mins to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5129..5133

                                                                                                                                                                        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 49.

                                                                                                                                                                        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 ((buf[1] & 0xC0) !== 0x80) {
                                                                                                                                                                              self.lastNeed = 1;
                                                                                                                                                                              return '\ufffd'.repeat(p + 1);
                                                                                                                                                                            }
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 30 mins to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5842..5845

                                                                                                                                                                        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

                                                                                                                                                                              if ((buf[2] & 0xC0) !== 0x80) {
                                                                                                                                                                                self.lastNeed = 2;
                                                                                                                                                                                return '\ufffd'.repeat(p + 2);
                                                                                                                                                                              }
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in web/iconv-lite.js and 1 other location - About 30 mins to fix
                                                                                                                                                                        web/iconv-lite.js on lines 5837..5840

                                                                                                                                                                        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