Sign upLogin

Prodigious-Aim-Solutions/Kronicle6

View on GitHub
Star
examples/browser/main.js

Summary

Maintainability
F
3 mos
Test Coverage

File main.js has 3562 lines of code (exceeds 250 allowed). Consider refactoring.
Open

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

var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
Severity: Major
Found in examples/browser/main.js - About 1 wk to fix

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

    },{"./modules/$":34,"./modules/es5":49,"./modules/es6.array.copy-within":50,"./modules/es6.array.fill":51,"./modules/es6.array.find":53,"./modules/es6.array.find-index":52,"./modules/es6.array.from":54,"./modules/es6.array.iterator":55,"./modules/es6.array.of":56,"./modules/es6.array.species":57,"./modules/es6.function.has-instance":58,"./modules/es6.function.name":59,"./modules/es6.map":60,"./modules/es6.math":61,"./modules/es6.number.constructor":62,"./modules/es6.number.statics":63,"./modules/es6.object.assign":64,"./modules/es6.object.is":65,"./modules/es6.object.set-prototype-of":66,"./modules/es6.object.statics-accept-primitives":67,"./modules/es6.object.to-string":68,"./modules/es6.promise":69,"./modules/es6.reflect":70,"./modules/es6.regexp":71,"./modules/es6.set":72,"./modules/es6.string.code-point-at":73,"./modules/es6.string.ends-with":74,"./modules/es6.string.from-code-point":75,"./modules/es6.string.includes":76,"./modules/es6.string.iterator":77,"./modules/es6.string.raw":78,"./modules/es6.string.repeat":79,"./modules/es6.string.starts-with":80,"./modules/es6.symbol":81,"./modules/es6.weak-map":82,"./modules/es6.weak-set":83,"./modules/es7.array.includes":84,"./modules/es7.map.to-json":85,"./modules/es7.object.get-own-property-descriptors":86,"./modules/es7.object.to-array":87,"./modules/es7.regexp.escape":88,"./modules/es7.set.to-json":89,"./modules/es7.string.at":90,"./modules/es7.string.lpad":91,"./modules/es7.string.rpad":92,"./modules/js.array.statics":93,"./modules/web.dom.iterable":94,"./modules/web.immediate":95,"./modules/web.timers":96}],98:[function(require,module,exports){
(function (global){
/**
 * Copyright (c) 2014, Facebook, Inc.
 * All rights reserved.
    Severity: Minor
    Found in examples/browser/main.js - About 1 wk 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 98 has 400 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    },{"./modules/$":34,"./modules/es5":49,"./modules/es6.array.copy-within":50,"./modules/es6.array.fill":51,"./modules/es6.array.find":53,"./modules/es6.array.find-index":52,"./modules/es6.array.from":54,"./modules/es6.array.iterator":55,"./modules/es6.array.of":56,"./modules/es6.array.species":57,"./modules/es6.function.has-instance":58,"./modules/es6.function.name":59,"./modules/es6.map":60,"./modules/es6.math":61,"./modules/es6.number.constructor":62,"./modules/es6.number.statics":63,"./modules/es6.object.assign":64,"./modules/es6.object.is":65,"./modules/es6.object.set-prototype-of":66,"./modules/es6.object.statics-accept-primitives":67,"./modules/es6.object.to-string":68,"./modules/es6.promise":69,"./modules/es6.reflect":70,"./modules/es6.regexp":71,"./modules/es6.set":72,"./modules/es6.string.code-point-at":73,"./modules/es6.string.ends-with":74,"./modules/es6.string.from-code-point":75,"./modules/es6.string.includes":76,"./modules/es6.string.iterator":77,"./modules/es6.string.raw":78,"./modules/es6.string.repeat":79,"./modules/es6.string.starts-with":80,"./modules/es6.symbol":81,"./modules/es6.weak-map":82,"./modules/es6.weak-set":83,"./modules/es7.array.includes":84,"./modules/es7.map.to-json":85,"./modules/es7.object.get-own-property-descriptors":86,"./modules/es7.object.to-array":87,"./modules/es7.regexp.escape":88,"./modules/es7.set.to-json":89,"./modules/es7.string.at":90,"./modules/es7.string.lpad":91,"./modules/es7.string.rpad":92,"./modules/js.array.statics":93,"./modules/web.dom.iterable":94,"./modules/web.immediate":95,"./modules/web.timers":96}],98:[function(require,module,exports){
(function (global){
/**
 * Copyright (c) 2014, Facebook, Inc.
 * All rights reserved.
    Severity: Major
    Found in examples/browser/main.js - About 2 days to fix

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

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

var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
      Severity: Major
      Found in examples/browser/main.js - About 1 day to fix

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

        },{"./$":34,"./$.uid":46}],49:[function(require,module,exports){
var $                = require('./$')
  , cel              = require('./$.dom-create')
  , cof              = require('./$.cof')
  , $def             = require('./$.def')
        Severity: Minor
        Found in examples/browser/main.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 19 has a Cognitive Complexity of 78 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"./$":34,"./$.wks":48}],19:[function(require,module,exports){
'use strict';
var $        = require('./$')
  , ctx      = require('./$.ctx')
  , safe     = require('./$.uid').safe
        Severity: Minor
        Found in examples/browser/main.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 49 has 221 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        },{"./$":34,"./$.uid":46}],49:[function(require,module,exports){
var $                = require('./$')
  , cel              = require('./$.dom-create')
  , cof              = require('./$.cof')
  , $def             = require('./$.def')
        Severity: Major
        Found in examples/browser/main.js - About 1 day to fix

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

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

            Function 61 has a Cognitive Complexity of 53 (exceeds 5 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: Minor
            Found in examples/browser/main.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 69 has a Cognitive Complexity of 50 (exceeds 5 allowed). Consider refactoring.
            Open

            },{"./$":34,"./$.cof":18,"./$.wks":48}],69:[function(require,module,exports){
'use strict';
var $        = require('./$')
  , ctx      = require('./$.ctx')
  , cof      = require('./$.cof')
            Severity: Minor
            Found in examples/browser/main.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 70 has a Cognitive Complexity of 46 (exceeds 5 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: Minor
            Found in examples/browser/main.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 22 has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
            Open

            },{"./$":34,"./$.array-methods":15,"./$.assert":16,"./$.for-of":27,"./$.uid":46}],22:[function(require,module,exports){
'use strict';
var $     = require('./$')
  , $def  = require('./$.def')
  , BUGGY = require('./$.iter').BUGGY
            Severity: Minor
            Found in examples/browser/main.js - About 6 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 6 has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
            Open

            },{}],6:[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 6 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 81 has a Cognitive Complexity of 39 (exceeds 5 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: Minor
            Found in examples/browser/main.js - About 5 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 67 has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.
            Open

            },{"./$.def":24,"./$.set-proto":39}],67:[function(require,module,exports){
var $        = require('./$')
  , $def     = require('./$.def')
  , isObject = $.isObject
  , toObject = $.toObject;
            Severity: Minor
            Found in examples/browser/main.js - About 5 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 140 lines of code (exceeds 25 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: Major
            Found in examples/browser/main.js - About 5 hrs to fix

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

              },{"./$.assert":16}],31:[function(require,module,exports){
var $def            = require('./$.def')
  , $               = require('./$')
  , cof             = require('./$.cof')
  , $iter           = require('./$.iter')
              Severity: Minor
              Found in examples/browser/main.js - About 5 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 101 has 136 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              },{"babel-core/polyfill":99}],101:[function(require,module,exports){
/*
Copyright (c) 2010,2011,2012,2013,2014 Morgan Roderick http://roderick.dk
License: MIT - http://mrgnrdrck.mit-license.org
              Severity: Major
              Found in examples/browser/main.js - About 5 hrs to fix

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

                var DataSource = exports.DataSource = (function (Module) {
    function DataSource() {
        var args = arguments[0] === undefined ? { source: undefined, name: "" } : arguments[0];
        _classCallCheck(this, DataSource);
                Severity: Major
                Found in examples/browser/main.js - About 5 hrs to fix

                  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

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

                                      },{"./$.def":24}],62:[function(require,module,exports){
'use strict';
var $          = require('./$')
  , isObject   = $.isObject
  , isFunction = $.isFunction
                                      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

                                      Function 5 has 72 lines of code (exceeds 25 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: Major
                                      Found in examples/browser/main.js - About 2 hrs to fix

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

                                        },{}],29:[function(require,module,exports){
// Fast apply
// http://jsperf.lnkit.com/fast-apply/5
module.exports = function(fn, args, that){
  var un = that === undefined;
                                        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

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

                                        },{"../Module.js":4,"./DataSourcesEvents.js":10,"pubsub-js":101}],9:[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 2 hrs to fix

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

                                          var ArrayDataSource = exports.ArrayDataSource = (function () {
    function ArrayDataSource() {
        _classCallCheck(this, ArrayDataSource);

        this.data = [];
                                          Severity: Major
                                          Found in examples/browser/main.js - About 2 hrs to fix

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

                                            var Kronicle = exports.Kronicle = (function () {
    function Kronicle() {
        _classCallCheck(this, Kronicle);

        this.core = null;
                                            Severity: Major
                                            Found in examples/browser/main.js - About 2 hrs to fix

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

                                              },{"./$":34,"./$.wks":48}],41:[function(require,module,exports){
// true  -> String#at
// false -> String#codePointAt
var $ = require('./$');
module.exports = function(TO_STRING){
                                              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

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

                                              },{"../Module.js":4,"./DataSourcesEvents.js":10,"pubsub-js":101}],9:[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 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 6 has 64 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                              },{}],6:[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: Major
                                              Found in examples/browser/main.js - About 2 hrs to fix

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

                                                },{"./$":34,"./$.array-methods":15,"./$.assert":16,"./$.for-of":27,"./$.uid":46}],22:[function(require,module,exports){
'use strict';
var $     = require('./$')
  , $def  = require('./$.def')
  , BUGGY = require('./$.iter').BUGGY
                                                Severity: Major
                                                Found in examples/browser/main.js - About 2 hrs to fix

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

                                                  var DataSources = exports.DataSources = (function (Module) {
    function DataSources() {
        var sources = arguments[0] === undefined ? [] : arguments[0];
        _classCallCheck(this, DataSources);
                                                  Severity: Major
                                                  Found in examples/browser/main.js - About 2 hrs to fix

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

                                                    var Component = exports.Component = (function (Module) {
    function Component() {
        var args = arguments[0] === undefined ? { components: [], template: function () {
                return "";
            }, name: "" } : arguments[0];
                                                    Severity: Major
                                                    Found in examples/browser/main.js - About 2 hrs to fix

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

                                                      (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
                                                      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

                                                      Function 11 has 52 lines of code (exceeds 25 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: Major
                                                      Found in examples/browser/main.js - About 2 hrs to fix

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

                                                          getConstructor: function(NAME, IS_MAP, ADDER){
    function C(){
      var that     = assert.inst(this, C, NAME)
        , iterable = arguments[0];
      set(that, O1, $.create(null));
                                                        Severity: Major
                                                        Found in examples/browser/main.js - About 2 hrs to fix

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

                                                          },{"./$":34,"./$.def":24,"./$.invoke":29,"./$.partial":37}],97:[function(require,module,exports){
require('./modules/es5');
require('./modules/es6.symbol');
require('./modules/es6.object.assign');
require('./modules/es6.object.is');
                                                          Severity: Minor
                                                          Found in examples/browser/main.js - About 1 hr to fix

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

                                                            },{"./$.species":40}],58:[function(require,module,exports){
var $             = require('./$')
  , HAS_INSTANCE  = require('./$.wks')('hasInstance')
  , FunctionProto = Function.prototype;
// 19.2.3.6 Function.prototype[@@hasInstance](V)
                                                            Severity: Minor
                                                            Found in examples/browser/main.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 exports has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                            module.exports = function(NAME, methods, common, IS_MAP, IS_WEAK){
  var Base  = $.g[NAME]
    , C     = Base
    , ADDER = IS_MAP ? 'set' : 'add'
    , proto = C && C.prototype
                                                            Severity: Minor
                                                            Found in examples/browser/main.js - About 1 hr to fix

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

                                                              },{"./$.assert":16}],31:[function(require,module,exports){
var $def            = require('./$.def')
  , $               = require('./$')
  , cof             = require('./$.cof')
  , $iter           = require('./$.iter')
                                                              Severity: Minor
                                                              Found in examples/browser/main.js - About 1 hr to fix

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

                                                                },{"./$":34,"./$.enum-keys":26}],18:[function(require,module,exports){
var $        = require('./$')
  , TAG      = require('./$.wks')('toStringTag')
  , toString = {}.toString;
function cof(it){
                                                                Severity: Minor
                                                                Found in examples/browser/main.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 62 has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                },{"./$.def":24}],62:[function(require,module,exports){
'use strict';
var $          = require('./$')
  , isObject   = $.isObject
  , isFunction = $.isFunction
                                                                Severity: Minor
                                                                Found in examples/browser/main.js - About 1 hr to fix

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

                                                                  var View = exports.View = (function (Module) {
    function View(args) {
        _classCallCheck(this, View);

        this.template = args.template || function () {
                                                                  Severity: Minor
                                                                  Found in examples/browser/main.js - About 1 hr to fix

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

                                                                    },{"./$":34}],42:[function(require,module,exports){
// http://wiki.ecmascript.org/doku.php?id=strawman:string_padding
var $      = require('./$')
  , repeat = require('./$.string-repeat');
                                                                    Severity: Minor
                                                                    Found in examples/browser/main.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 71 has 39 lines of code (exceeds 25 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 1 hr to fix

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

                                                                      },{"./$.def":24,"./$.set-proto":39}],67:[function(require,module,exports){
var $        = require('./$')
  , $def     = require('./$.def')
  , isObject = $.isObject
  , toObject = $.toObject;
                                                                      Severity: Minor
                                                                      Found in examples/browser/main.js - About 1 hr to fix

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

                                                                            dispatchException: function(exception) {
      if (this.done) {
        throw exception;
      }
                                                                        Severity: Minor
                                                                        Found in examples/browser/main.js - About 1 hr to fix

                                                                          Function 24 has 36 lines of code (exceeds 25 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 1 hr to fix

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

                                                                            },{"./$.wks":48}],33:[function(require,module,exports){
'use strict';
var $                 = require('./$')
  , cof               = require('./$.cof')
  , assertObject      = require('./$.assert').obj
                                                                            Severity: Minor
                                                                            Found in examples/browser/main.js - About 1 hr to fix

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

                                                                              },{"./$":34,"./$.assert":16,"./$.cof":18,"./$.def":24,"./$.enum-keys":26,"./$.keyof":35,"./$.uid":46,"./$.wks":48}],82:[function(require,module,exports){
'use strict';
var $         = require('./$')
  , weak      = require('./$.collection-weak')
  , leakStore = weak.leakStore
                                                                              Severity: Minor
                                                                              Found in examples/browser/main.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 15 has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                              },{"./$":34}],15:[function(require,module,exports){
// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
                                                                              Severity: Minor
                                                                              Found in examples/browser/main.js - About 1 hr to fix

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

                                                                                module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){
  $iter.create(Constructor, NAME, next);
  function createMethod(kind){
    function $$(that){
      return new Constructor(that, kind);
                                                                                Severity: Minor
                                                                                Found in examples/browser/main.js - About 1 hr to fix

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

                                                                                  },{"./$":34}],44:[function(require,module,exports){
'use strict';
var $      = require('./$')
  , ctx    = require('./$.ctx')
  , cof    = require('./$.cof')
                                                                                  Severity: Minor
                                                                                  Found in examples/browser/main.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 3 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                                                                                  Open

                                                                                  },{}],3:[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 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 16 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                                                                                  Open

                                                                                  },{"./$":34,"./$.ctx":23}],16:[function(require,module,exports){
var $ = require('./$');
function assert(condition, msg1, msg2){
  if(!condition)throw TypeError(msg2 ? msg1 + msg2 : msg1);
}
                                                                                  Severity: Minor
                                                                                  Found in examples/browser/main.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 82 has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                  },{"./$":34,"./$.assert":16,"./$.cof":18,"./$.def":24,"./$.enum-keys":26,"./$.keyof":35,"./$.uid":46,"./$.wks":48}],82:[function(require,module,exports){
'use strict';
var $         = require('./$')
  , weak      = require('./$.collection-weak')
  , leakStore = weak.leakStore
                                                                                  Severity: Minor
                                                                                  Found in examples/browser/main.js - About 1 hr to fix

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

                                                                                    module.exports = function(TYPE){
  var IS_MAP        = TYPE == 1
    , IS_FILTER     = TYPE == 2
    , IS_SOME       = TYPE == 3
    , IS_EVERY      = TYPE == 4
                                                                                    Severity: Minor
                                                                                    Found in examples/browser/main.js - About 1 hr to fix

                                                                                      Function 54 has 28 lines of code (exceeds 25 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 1 hr to fix

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

                                                                                            PubSub.unsubscribe = function(value){
        var isTopic    = typeof value === 'string' && messages.hasOwnProperty(value),
            isToken    = !isTopic && typeof value === 'string',
            isFunction = typeof value === 'function',
            result = false,
                                                                                        Severity: Minor
                                                                                        Found in examples/browser/main.js - About 1 hr to fix

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

                                                                                          },{"./$":34,"./$.array-includes":14,"./$.array-methods":15,"./$.assert":16,"./$.cof":18,"./$.def":24,"./$.dom-create":25,"./$.invoke":29,"./$.replacer":38,"./$.throws":45,"./$.uid":46}],50:[function(require,module,exports){
'use strict';
var $       = require('./$')
  , $def    = require('./$.def')
  , toIndex = $.toIndex;
                                                                                          Severity: Minor
                                                                                          Found in examples/browser/main.js - About 1 hr to fix

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

                                                                                            },{"./$":34}],63:[function(require,module,exports){
var $     = require('./$')
  , $def  = require('./$.def')
  , abs   = Math.abs
  , floor = Math.floor
                                                                                            Severity: Minor
                                                                                            Found in examples/browser/main.js - About 1 hr to fix

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

                                                                                              },{"./$":34,"./$.array-includes":14,"./$.array-methods":15,"./$.assert":16,"./$.cof":18,"./$.def":24,"./$.dom-create":25,"./$.invoke":29,"./$.replacer":38,"./$.throws":45,"./$.uid":46}],50:[function(require,module,exports){
'use strict';
var $       = require('./$')
  , $def    = require('./$.def')
  , toIndex = $.toIndex;
                                                                                              Severity: Minor
                                                                                              Found in examples/browser/main.js - About 55 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

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

                                                                                              },{"./Core.js":1,"./EventTypes.js":2,"pubsub-js":101}],4:[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 55 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

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

                                                                                              },{}],39:[function(require,module,exports){
// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */
var $      = require('./$')
  , assert = require('./$.assert');
                                                                                              Severity: Minor
                                                                                              Found in examples/browser/main.js - About 55 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

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

                                                                                              module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){
                                                                                              Severity: Major
                                                                                              Found in examples/browser/main.js - About 50 mins to fix

                                                                                                Avoid deeply nested control flow statements.
                                                                                                Open

                                                                                                              if (record.type === "throw") {
                // If the return method threw an exception, let that
                // exception prevail over the original return or throw.
                method = "throw";
                arg = record.arg;
                                                                                                Severity: Major
                                                                                                Found in examples/browser/main.js - About 45 mins to fix

                                                                                                  Avoid deeply nested control flow statements.
                                                                                                  Open

                                                                                                            } else if (hasFinally) {
            if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }
                                                                                                  Severity: Major
                                                                                                  Found in examples/browser/main.js - About 45 mins to fix

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

                                                                                                    },{"./$":34,"./$.cof":18,"./$.def":24,"./$.throws":45}],75:[function(require,module,exports){
var $def    = require('./$.def')
  , toIndex = require('./$').toIndex
  , fromCharCode = String.fromCharCode
  , $fromCodePoint = String.fromCodePoint;
                                                                                                    Severity: Minor
                                                                                                    Found in examples/browser/main.js - About 45 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

                                                                                                    Avoid deeply nested control flow statements.
                                                                                                    Open

                                                                                                                            if (message.hasOwnProperty(t) && message[t] === value){
                            delete message[t];
                            result = true;
                        }
                                                                                                    Severity: Major
                                                                                                    Found in examples/browser/main.js - About 45 mins to fix

                                                                                                      Avoid deeply nested control flow statements.
                                                                                                      Open

                                                                                                                  if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            }
                                                                                                      Severity: Major
                                                                                                      Found in examples/browser/main.js - About 45 mins to fix

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

                                                                                                        },{"./$":34,"./$.string-repeat":43}],43:[function(require,module,exports){
'use strict';
var $ = require('./$');

module.exports = function repeat(count){
                                                                                                        Severity: Minor
                                                                                                        Found in examples/browser/main.js - About 45 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

                                                                                                        Avoid deeply nested control flow statements.
                                                                                                        Open

                                                                                                                } else if(IS_EVERY)return false;          // every
                                                                                                        Severity: Major
                                                                                                        Found in examples/browser/main.js - About 45 mins to fix

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

                                                                                                          },{"../../build/Kronicle.js":3,"../../build/lib/ArrayDataSource.js":5,"../../build/lib/Component.js":6,"../../build/lib/Controller.js":7,"../../build/lib/DataSource.js":8,"../../build/lib/DataSources.js":9,"../../build/lib/View.js":11}],13:[function(require,module,exports){
(function (global){
"use strict";

require("core-js/shim");
                                                                                                          Severity: Minor
                                                                                                          Found in examples/browser/main.js - About 45 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

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                  else if(res)switch(TYPE){
          case 3: return true;                    // some
          case 5: return val;                     // find
          case 6: return index;                   // findIndex
          case 2: result.push(val);               // filter
                                                                                                          Severity: Major
                                                                                                          Found in examples/browser/main.js - About 45 mins to fix

                                                                                                            Consider simplifying this complex logical expression.
                                                                                                            Open

                                                                                                              if(!$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)){
    // create collection constructor
    C = common.getConstructor(NAME, IS_MAP, ADDER);
    $.mix(C.prototype, methods);
  } else {
                                                                                                            Severity: Major
                                                                                                            Found in examples/browser/main.js - About 40 mins to fix

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

                                                                                                              module.exports = function(NAME, methods, common, IS_MAP, IS_WEAK){
                                                                                                              Severity: Minor
                                                                                                              Found in examples/browser/main.js - About 35 mins to fix

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

                                                                                                                },{"./$":34}],27:[function(require,module,exports){
var ctx  = require('./$.ctx')
  , get  = require('./$.iter').get
  , call = require('./$.iter-call');
module.exports = function(iterable, entries, fn, that){
                                                                                                                Severity: Minor
                                                                                                                Found in examples/browser/main.js - About 35 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

                                                                                                                Avoid too many return statements within this function.
                                                                                                                Open

                                                                                                                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: Major
                                                                                                                Found in examples/browser/main.js - About 30 mins to fix

                                                                                                                  Avoid too many return statements within this function.
                                                                                                                  Open

                                                                                                                  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: Major
                                                                                                                  Found in examples/browser/main.js - About 30 mins to fix

                                                                                                                    Avoid too many return statements within this function.
                                                                                                                    Open

                                                                                                                                  return handle(entry.finallyLoc);
                                                                                                                    Severity: Major
                                                                                                                    Found in examples/browser/main.js - About 30 mins to fix

                                                                                                                      Avoid too many return statements within this function.
                                                                                                                      Open

                                                                                                                      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: Major
                                                                                                                      Found in examples/browser/main.js - About 30 mins to fix

                                                                                                                        Avoid too many return statements within this function.
                                                                                                                        Open

                                                                                                                        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: Major
                                                                                                                        Found in examples/browser/main.js - About 30 mins to fix

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

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

var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
                                                                                                                          Severity: Minor
                                                                                                                          Found in examples/browser/main.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

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

                                                                                                                          },{"babel-core/polyfill":99}],101:[function(require,module,exports){
/*
Copyright (c) 2010,2011,2012,2013,2014 Morgan Roderick http://roderick.dk
License: MIT - http://mrgnrdrck.mit-license.org
                                                                                                                          Severity: Minor
                                                                                                                          Found in examples/browser/main.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

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

                                                                                                                          },{}],30:[function(require,module,exports){
var assertObject = require('./$.assert').obj;
function close(iterator){
  var ret = iterator['return'];
  if(ret !== undefined)assertObject(ret.call(iterator));
                                                                                                                          Severity: Minor
                                                                                                                          Found in examples/browser/main.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

                                                                                                                          var DataSource = exports.DataSource = (function (Module) {
    function DataSource() {
        var args = arguments[0] === undefined ? { source: undefined, name: "" } : arguments[0];
        _classCallCheck(this, DataSource);
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 6 days to fix
                                                                                                                          build/lib/DataSource.js on lines 23..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 1100.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var ArrayDataSource = exports.ArrayDataSource = (function () {
    function ArrayDataSource() {
        _classCallCheck(this, ArrayDataSource);

        this.data = [];
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 3 days to fix
                                                                                                                          build/lib/ArrayDataSource.js on lines 11..122

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var DataSources = exports.DataSources = (function (Module) {
    function DataSources() {
        var sources = arguments[0] === undefined ? [] : arguments[0];
        _classCallCheck(this, DataSources);
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 2 days to fix
                                                                                                                          build/lib/DataSources.js on lines 29..120

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var Component = exports.Component = (function (Module) {
    function Component() {
        var args = arguments[0] === undefined ? { components: [], template: function () {
                return "";
            }, name: "" } : arguments[0];
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 2 days to fix
                                                                                                                          build/lib/Component.js on lines 23..97

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var Kronicle = exports.Kronicle = (function () {
    function Kronicle() {
        _classCallCheck(this, Kronicle);

        this.core = null;
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 2 days to fix
                                                                                                                          build/Kronicle.js on lines 19..118

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var View = exports.View = (function (Module) {
    function View(args) {
        _classCallCheck(this, View);

        this.template = args.template || function () {
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 2 days to fix
                                                                                                                          build/lib/View.js on lines 21..83

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var Controller = exports.Controller = (function (Module) {
    function Controller() {
        var args = arguments[0] === undefined ? { model: {}, view: {}, name: "" } : arguments[0];
        _classCallCheck(this, Controller);
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 1 day to fix
                                                                                                                          build/lib/Controller.js on lines 19..34

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var Core = exports.Core = function Core(modules) {
    _classCallCheck(this, Core);

    PubSub.publish(events.Initialized);
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 1 day to fix
                                                                                                                          build/Core.js on lines 18..37

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

                                                                                                                          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

                                                                                                                          },{"./$.array-methods":15,"./$.def":24,"./$.unscope":47}],53:[function(require,module,exports){
'use strict';
// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
var KEY    = 'find'
  , $def   = require('./$.def')
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 6 hrs to fix
                                                                                                                          examples/browser/main.js on lines 2395..2410

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

                                                                                                                          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

                                                                                                                          },{"./$":34,"./$.def":24,"./$.unscope":47}],52:[function(require,module,exports){
'use strict';
// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
var KEY    = 'findIndex'
  , $def   = require('./$.def')
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 6 hrs to fix
                                                                                                                          examples/browser/main.js on lines 2410..2425

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

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

                                                                                                                          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: Major
                                                                                                                          Found in examples/browser/main.js and 7 other locations - About 5 hrs to fix
                                                                                                                          build/lib/Component.js on lines 5..5
                                                                                                                          build/lib/Controller.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 5..5
                                                                                                                          examples/browser/main.js on lines 351..351
                                                                                                                          examples/browser/main.js on lines 450..450
                                                                                                                          examples/browser/main.js on lines 880..880

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

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

                                                                                                                          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: Major
                                                                                                                          Found in examples/browser/main.js and 7 other locations - About 5 hrs to fix
                                                                                                                          build/lib/Component.js on lines 5..5
                                                                                                                          build/lib/Controller.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 5..5
                                                                                                                          examples/browser/main.js on lines 450..450
                                                                                                                          examples/browser/main.js on lines 492..492
                                                                                                                          examples/browser/main.js on lines 880..880

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

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

                                                                                                                          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: Major
                                                                                                                          Found in examples/browser/main.js and 7 other locations - About 5 hrs to fix
                                                                                                                          build/lib/Component.js on lines 5..5
                                                                                                                          build/lib/Controller.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 5..5
                                                                                                                          examples/browser/main.js on lines 351..351
                                                                                                                          examples/browser/main.js on lines 450..450
                                                                                                                          examples/browser/main.js on lines 492..492

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

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

                                                                                                                          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: Major
                                                                                                                          Found in examples/browser/main.js and 7 other locations - About 5 hrs to fix
                                                                                                                          build/lib/Component.js on lines 5..5
                                                                                                                          build/lib/Controller.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 5..5
                                                                                                                          examples/browser/main.js on lines 351..351
                                                                                                                          examples/browser/main.js on lines 492..492
                                                                                                                          examples/browser/main.js on lines 880..880

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var Module = exports.Module = (function () {
    function Module() {
        var args = arguments[0] === undefined ? { name: "" } : arguments[0];
        _classCallCheck(this, Module);
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 5 hrs to fix
                                                                                                                          build/Module.js on lines 11..32

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 9 other locations - About 4 hrs to fix
                                                                                                                          build/lib/Component.js on lines 7..7
                                                                                                                          build/lib/Controller.js on lines 5..5
                                                                                                                          build/lib/DataSource.js on lines 9..9
                                                                                                                          build/lib/DataSources.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 7..7
                                                                                                                          examples/browser/main.js on lines 353..353
                                                                                                                          examples/browser/main.js on lines 494..494
                                                                                                                          examples/browser/main.js on lines 736..736
                                                                                                                          examples/browser/main.js on lines 882..882

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 9 other locations - About 4 hrs to fix
                                                                                                                          build/lib/Component.js on lines 7..7
                                                                                                                          build/lib/Controller.js on lines 5..5
                                                                                                                          build/lib/DataSource.js on lines 9..9
                                                                                                                          build/lib/DataSources.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 7..7
                                                                                                                          examples/browser/main.js on lines 353..353
                                                                                                                          examples/browser/main.js on lines 452..452
                                                                                                                          examples/browser/main.js on lines 736..736
                                                                                                                          examples/browser/main.js on lines 882..882

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 9 other locations - About 4 hrs to fix
                                                                                                                          build/lib/Component.js on lines 7..7
                                                                                                                          build/lib/Controller.js on lines 5..5
                                                                                                                          build/lib/DataSource.js on lines 9..9
                                                                                                                          build/lib/DataSources.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 7..7
                                                                                                                          examples/browser/main.js on lines 353..353
                                                                                                                          examples/browser/main.js on lines 452..452
                                                                                                                          examples/browser/main.js on lines 494..494
                                                                                                                          examples/browser/main.js on lines 736..736

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 9 other locations - About 4 hrs to fix
                                                                                                                          build/lib/Component.js on lines 7..7
                                                                                                                          build/lib/Controller.js on lines 5..5
                                                                                                                          build/lib/DataSource.js on lines 9..9
                                                                                                                          build/lib/DataSources.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 7..7
                                                                                                                          examples/browser/main.js on lines 452..452
                                                                                                                          examples/browser/main.js on lines 494..494
                                                                                                                          examples/browser/main.js on lines 736..736
                                                                                                                          examples/browser/main.js on lines 882..882

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

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 9 other locations - About 4 hrs to fix
                                                                                                                          build/lib/Component.js on lines 7..7
                                                                                                                          build/lib/Controller.js on lines 5..5
                                                                                                                          build/lib/DataSource.js on lines 9..9
                                                                                                                          build/lib/DataSources.js on lines 7..7
                                                                                                                          build/lib/View.js on lines 7..7
                                                                                                                          examples/browser/main.js on lines 353..353
                                                                                                                          examples/browser/main.js on lines 452..452
                                                                                                                          examples/browser/main.js on lines 494..494
                                                                                                                          examples/browser/main.js on lines 882..882

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

                                                                                                                          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

                                                                                                                          var helloCtrl = new Controller({
    name: 'HelloWorld',
    // View for controller, also called HelloWorld, will be renamed internally to HelloWorldView
    view: new View({
        name: 'HelloWorld',
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 1 hr to fix
                                                                                                                          examples/browser/src.js on lines 21..31

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

                                                                                                                          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

                                                                                                                          },{"./$.def":24,"./$.string-at":41}],91:[function(require,module,exports){
'use strict';
var $def = require('./$.def')
  , $pad = require('./$.string-pad');
$def($def.P, 'String', {
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 1 hr to fix
                                                                                                                          examples/browser/main.js on lines 3677..3686

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 69.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          },{"./$.def":24,"./$.string-pad":42}],92:[function(require,module,exports){
'use strict';
var $def = require('./$.def')
  , $pad = require('./$.string-pad');
$def($def.P, 'String', {
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 1 hr to fix
                                                                                                                          examples/browser/main.js on lines 3668..3677

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 69.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 67..67
                                                                                                                          examples/browser/main.js on lines 223..223
                                                                                                                          examples/browser/main.js on lines 349..349
                                                                                                                          examples/browser/main.js on lines 490..490
                                                                                                                          examples/browser/main.js on lines 734..734
                                                                                                                          examples/browser/main.js on lines 878..878

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 67..67
                                                                                                                          examples/browser/main.js on lines 187..187
                                                                                                                          examples/browser/main.js on lines 223..223
                                                                                                                          examples/browser/main.js on lines 349..349
                                                                                                                          examples/browser/main.js on lines 490..490
                                                                                                                          examples/browser/main.js on lines 878..878

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 67..67
                                                                                                                          examples/browser/main.js on lines 187..187
                                                                                                                          examples/browser/main.js on lines 349..349
                                                                                                                          examples/browser/main.js on lines 490..490
                                                                                                                          examples/browser/main.js on lines 734..734
                                                                                                                          examples/browser/main.js on lines 878..878

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 67..67
                                                                                                                          examples/browser/main.js on lines 187..187
                                                                                                                          examples/browser/main.js on lines 223..223
                                                                                                                          examples/browser/main.js on lines 349..349
                                                                                                                          examples/browser/main.js on lines 734..734
                                                                                                                          examples/browser/main.js on lines 878..878

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 187..187
                                                                                                                          examples/browser/main.js on lines 223..223
                                                                                                                          examples/browser/main.js on lines 349..349
                                                                                                                          examples/browser/main.js on lines 490..490
                                                                                                                          examples/browser/main.js on lines 734..734
                                                                                                                          examples/browser/main.js on lines 878..878

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 67..67
                                                                                                                          examples/browser/main.js on lines 187..187
                                                                                                                          examples/browser/main.js on lines 223..223
                                                                                                                          examples/browser/main.js on lines 490..490
                                                                                                                          examples/browser/main.js on lines 734..734
                                                                                                                          examples/browser/main.js on lines 878..878

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
                                                                                                                          Severity: Major
                                                                                                                          Found in examples/browser/main.js and 13 other locations - About 50 mins to fix
                                                                                                                          build/Kronicle.js on lines 5..5
                                                                                                                          build/Module.js on lines 3..3
                                                                                                                          build/lib/ArrayDataSource.js on lines 3..3
                                                                                                                          build/lib/Component.js on lines 3..3
                                                                                                                          build/lib/DataSource.js on lines 5..5
                                                                                                                          build/lib/DataSources.js on lines 5..5
                                                                                                                          build/lib/View.js on lines 3..3
                                                                                                                          examples/browser/main.js on lines 67..67
                                                                                                                          examples/browser/main.js on lines 187..187
                                                                                                                          examples/browser/main.js on lines 223..223
                                                                                                                          examples/browser/main.js on lines 349..349
                                                                                                                          examples/browser/main.js on lines 490..490
                                                                                                                          examples/browser/main.js on lines 734..734

                                                                                                                          Duplicated Code

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

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

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

                                                                                                                          Tuning

                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                          Refactorings

                                                                                                                          Further Reading

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

                                                                                                                          assert.obj = function(it){
  if(!$.isObject(it))throw TypeError(it + ' is not an object!');
  return it;
};
                                                                                                                          Severity: Minor
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 30 mins to fix
                                                                                                                          examples/browser/main.js on lines 1075..1078

                                                                                                                          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

                                                                                                                          assert.fn = function(it){
  if(!$.isFunction(it))throw TypeError(it + ' is not a function!');
  return it;
};
                                                                                                                          Severity: Minor
                                                                                                                          Found in examples/browser/main.js and 1 other location - About 30 mins to fix
                                                                                                                          examples/browser/main.js on lines 1079..1082

                                                                                                                          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