Prodigious-Aim-Solutions/Kronicle6

View on GitHub

Showing 121 of 186 total issues

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

},{"./$":34,"./$.wks":48}],19:[function(require,module,exports){
'use strict';
var $        = require('./$')
  , ctx      = require('./$.ctx')
  , safe     = require('./$.uid').safe
Severity: Major
Found in examples/browser/main.js - About 5 hrs to fix

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

    },{"./$":34,"./$.cof":18,"./$.def":24,"./$.throws":45}],81:[function(require,module,exports){
    'use strict';
    // ECMAScript 6 symbols shim
    var $        = require('./$')
      , setTag   = require('./$.cof').set
    Severity: Major
    Found in examples/browser/main.js - About 5 hrs to fix

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

      },{"./$.assert":16}],24:[function(require,module,exports){
      var $          = require('./$')
        , global     = $.g
        , core       = $.core
        , isFunction = $.isFunction;
      Severity: Minor
      Found in examples/browser/main.js - About 4 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 71 has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
      Open

      },{"./$":34,"./$.assert":16,"./$.def":24,"./$.iter":33,"./$.own-keys":36,"./$.set-proto":39,"./$.uid":46,"./$.wks":48}],71:[function(require,module,exports){
      var $       = require('./$')
        , cof     = require('./$.cof')
        , $RegExp = $.g.RegExp
        , Base    = $RegExp
      Severity: Minor
      Found in examples/browser/main.js - About 4 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 70 has 122 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      },{"./$":34,"./$.assert":16,"./$.cof":18,"./$.ctx":23,"./$.def":24,"./$.for-of":27,"./$.iter-detect":32,"./$.set-proto":39,"./$.species":40,"./$.task":44,"./$.uid":46,"./$.wks":48}],70:[function(require,module,exports){
      var $         = require('./$')
        , $def      = require('./$.def')
        , setProto  = require('./$.set-proto')
        , $iter     = require('./$.iter')
      Severity: Major
      Found in examples/browser/main.js - About 4 hrs to fix

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

        },{"../EventTypes.js":2}],11:[function(require,module,exports){
        "use strict";
        
        var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
        
        
        Severity: Minor
        Found in examples/browser/main.js - About 4 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 8 has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"../Module.js":4}],8:[function(require,module,exports){
        "use strict";
        
        var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
        
        
        Severity: Minor
        Found in examples/browser/main.js - About 4 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 21 has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"./$.def":24,"./$.for-of":27}],21:[function(require,module,exports){
        'use strict';
        var $         = require('./$')
          , safe      = require('./$.uid').safe
          , assert    = require('./$.assert')
        Severity: Minor
        Found in examples/browser/main.js - About 4 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 14 has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"core-js/shim":97,"regenerator/runtime":98}],14:[function(require,module,exports){
        // false -> Array#indexOf
        // true  -> Array#includes
        var $ = require('./$');
        module.exports = function(IS_INCLUDES){
        Severity: Minor
        Found in examples/browser/main.js - About 4 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 61 has 100 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        },{"./$.collection":22,"./$.collection-strong":19}],61:[function(require,module,exports){
        var Infinity = 1 / 0
          , $def  = require('./$.def')
          , E     = Math.E
          , pow   = Math.pow
        Severity: Major
        Found in examples/browser/main.js - About 4 hrs to fix

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

          },{}],5:[function(require,module,exports){
          "use strict";
          
          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
          
          
          Severity: Minor
          Found in examples/browser/main.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 makeInvokeMethod has 92 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function makeInvokeMethod(innerFn, self, context) {
              var state = GenStateSuspendedStart;
          
              return function invoke(method, arg) {
                if (state === GenStateExecuting) {
          Severity: Major
          Found in examples/browser/main.js - About 3 hrs to fix

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

            },{"./$":34,"./$.assert":16,"./$.cof":18,"./$.wks":48}],34:[function(require,module,exports){
            'use strict';
            var global = typeof self != 'undefined' ? self : Function('return this')()
              , core   = {}
              , defineProperty = Object.defineProperty
            Severity: Major
            Found in examples/browser/main.js - About 3 hrs to fix

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

              },{"./$.array-methods":15,"./$.def":24,"./$.unscope":47}],54:[function(require,module,exports){
              var $     = require('./$')
                , ctx   = require('./$.ctx')
                , $def  = require('./$.def')
                , $iter = require('./$.iter')
              Severity: Minor
              Found in examples/browser/main.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 invoke has 89 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  return function invoke(method, arg) {
                    if (state === GenStateExecuting) {
                      throw new Error("Generator is already running");
                    }
              
              
              Severity: Major
              Found in examples/browser/main.js - About 3 hrs to fix

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

                },{"./$":34,"./$.assert":16,"./$.cof":18,"./$.wks":48}],34:[function(require,module,exports){
                'use strict';
                var global = typeof self != 'undefined' ? self : Function('return this')()
                  , core   = {}
                  , defineProperty = Object.defineProperty
                Severity: Minor
                Found in examples/browser/main.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 21 has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                },{"./$.def":24,"./$.for-of":27}],21:[function(require,module,exports){
                'use strict';
                var $         = require('./$')
                  , safe      = require('./$.uid').safe
                  , assert    = require('./$.assert')
                Severity: Major
                Found in examples/browser/main.js - About 3 hrs to fix

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

                  },{}],3:[function(require,module,exports){
                  "use strict";
                  
                  var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
                  
                  
                  Severity: Major
                  Found in examples/browser/main.js - About 3 hrs to fix

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

                    },{"./$":34}],44:[function(require,module,exports){
                    'use strict';
                    var $      = require('./$')
                      , ctx    = require('./$.ctx')
                      , cof    = require('./$.cof')
                    Severity: Major
                    Found in examples/browser/main.js - About 2 hrs to fix

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

                      },{"../Module.js":4,"babel/polyfill":100}],7:[function(require,module,exports){
                      "use strict";
                      
                      var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
                      
                      
                      Severity: Minor
                      Found in examples/browser/main.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

                      Severity
                      Category
                      Status
                      Source
                      Language