Function `CSSLint` has a Cognitive Complexity of 2488 (exceeds 5 allowed). Consider refactoring.
Open

var CSSLint = (function(){
  var module = module || {},
      exports = exports || {};

/*!

Found in wp-includes/js/codemirror/csslint.js - About 1 mo to fix

Read up
Read up

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"

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

Found in wp-includes/js/codemirror/csslint.js - About 3 wks to fix

File `csslint.js` has 6554 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
CSSLint v1.0.4
Copyright (c) 2016 Nicole Sullivan and Nicholas C. Zakas. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy

Found in wp-includes/js/codemirror/csslint.js - About 2 wks to fix

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

},{"../util/SyntaxUnit":26,"./Parser":6}],6:[function(require,module,exports){
"use strict";

module.exports = Parser;

Found in wp-includes/js/codemirror/csslint.js - About 1 wk to fix

Function `prototype` has 1458 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Parser.prototype = function() {

    var proto = new EventTarget(),  //new prototype
        prop,
        additions =  {

Found in wp-includes/js/codemirror/csslint.js - About 1 wk to fix

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

},{"./Pseudos":12,"./SelectorPart":14}],17:[function(require,module,exports){
"use strict";

module.exports = TokenStream;

Found in wp-includes/js/codemirror/csslint.js - About 2 days to fix

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

},{"../util/EventTarget":23,"../util/SyntaxError":25,"../util/SyntaxUnit":26,"./Combinator":2,"./MediaFeature":4,"./MediaQuery":5,"./PropertyName":8,"./PropertyValue":9,"./PropertyValuePart":11,"./Selector":13,"./SelectorPart":14,"./SelectorSubPart":15,"./TokenStream":17,"./Tokens":18,"./Validation":19}],7:[function(require,module,exports){
"use strict";

/* exported Properties */

Found in wp-includes/js/codemirror/csslint.js - About 2 days to fix

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

},{}],21:[function(require,module,exports){
"use strict";

var ValidationTypes = module.exports;

Found in wp-includes/js/codemirror/csslint.js - About 1 day to fix

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

},{"../util/SyntaxUnit":26,"./Parser":6}],3:[function(require,module,exports){
"use strict";

module.exports = Matcher;

Found in wp-includes/js/codemirror/csslint.js - About 1 day to fix

Function `clone` has 184 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var clone = (function() {
'use strict';

var nativeMap;
try {

Found in wp-includes/js/codemirror/csslint.js - About 7 hrs to fix

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

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

/* exported Colors */

Found in wp-includes/js/codemirror/csslint.js - About 7 hrs to fix

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

},{}],11:[function(require,module,exports){
"use strict";

module.exports = PropertyValuePart;

Found in wp-includes/js/codemirror/csslint.js - About 6 hrs to fix

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

},{}],27:[function(require,module,exports){
"use strict";

module.exports = TokenStreamBase;

Found in wp-includes/js/codemirror/csslint.js - About 6 hrs to fix

Function `init` has 152 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    init: function (parser, reporter) {
        "use strict";
        var rule = this,
            compatiblePrefixes,
            properties,

Found in wp-includes/js/codemirror/csslint.js - About 6 hrs to fix

Function `CSSLint` has 151 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var CSSLint = (function() {
    "use strict";

    var rules           = [],
        formatters      = [],

Found in wp-includes/js/codemirror/csslint.js - About 6 hrs to fix

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

},{"../util/TokenStreamBase":27,"./PropertyValuePart":11,"./Tokens":18}],18:[function(require,module,exports){
"use strict";

var Tokens = module.exports = [

Found in wp-includes/js/codemirror/csslint.js - About 5 hrs to fix

Function `clone` has 132 lines of code (exceeds 25 allowed). Consider refactoring.
Open

function clone(parent, circular, depth, prototype, includeNonEnumerable) {
  if (typeof circular === 'object') {
    depth = circular.depth;
    prototype = circular.prototype;
    includeNonEnumerable = circular.includeNonEnumerable;

Found in wp-includes/js/codemirror/csslint.js - About 5 hrs to fix

Function `PropertyValuePart` has 128 lines of code (exceeds 25 allowed). Consider refactoring.
Open

function PropertyValuePart(text, line, col, optionalHint) {
    var hint = optionalHint || {};

    SyntaxUnit.call(this, text, line, col, Parser.PROPERTY_VALUE_PART_TYPE);

Found in wp-includes/js/codemirror/csslint.js - About 5 hrs to fix

Function `_clone` has 116 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  function _clone(parent, depth) {
    // cloning null always returns null
    if (parent === null)
      return null;

Found in wp-includes/js/codemirror/csslint.js - About 4 hrs to fix

Function `_stylesheet` has 112 lines of code (exceeds 25 allowed). Consider refactoring.
Open

            _stylesheet: function() {

                /*
                 * stylesheet
                 *  : [ CHARSET_SYM S* STRING S* ';' ]?

Found in wp-includes/js/codemirror/csslint.js - About 4 hrs to fix

Function `init` has 102 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            properties,
            num,

Found in wp-includes/js/codemirror/csslint.js - About 4 hrs to fix

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

},{}],24:[function(require,module,exports){
"use strict";

module.exports = StringReader;

Found in wp-includes/js/codemirror/csslint.js - About 3 hrs to fix

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

    _getToken: function() {

        var c,
            reader = this._reader,
            token   = null,

Found in wp-includes/js/codemirror/csslint.js - About 3 hrs to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this;

        var propertiesToCheck = {

Found in wp-includes/js/codemirror/csslint.js - About 3 hrs to fix

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

    api.verify = function(text, ruleset) {

        var i = 0,
            reporter,
            lines,

Found in wp-includes/js/codemirror/csslint.js - About 3 hrs to fix

Function `init` has 78 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            widthProperties = {
                border: 1,

Found in wp-includes/js/codemirror/csslint.js - About 3 hrs to fix

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

},{"../util/SyntaxUnit":26,"./Parser":6}],16:[function(require,module,exports){
"use strict";

module.exports = Specificity;

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

Function `many` has 72 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Matcher.many = function(required) {
    var ms = Array.prototype.slice.call(arguments, 1).reduce(function(acc, v) {
        if (v.expand) {
            // Insert all of the options for the given complex rule as
            // individual options.

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

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

Matcher.parse = function(str) {
    var reader, eat, expr, oror, andand, seq, mod, term, result;
    reader = new StringReader(str);
    eat = function(matcher) {
        var result = reader.readMatch(matcher);

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

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

            _term: function(inFunction) {

                /*
                 * term
                 *   : unary_operator?

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

Function `_document` has 59 lines of code (exceeds 25 allowed). Consider refactoring.
Open

            _document: function() {
                /*
                 * document
                 *   : DOCUMENT_SYM S*
                 *     _document_function [ ',' S* _document_function ]* S*

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

Function `_simple_selector_sequence` has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

            _simple_selector_sequence: function() {
                /*
                 * simple_selector_sequence
                 *   : [ type_selector | universal ]
                 *     [ HASH | class | attrib | pseudo | negation ]*

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

Function `init` has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            prop, i, len,
            propertiesToCheck = {},

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

Function `init` has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            lastProperty,
            propertiesToCheck = {

Found in wp-includes/js/codemirror/csslint.js - About 2 hrs to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this;

        var headings = {

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            lastRule;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

},{}],19:[function(require,module,exports){
"use strict";

/* exported Validation */

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _selector: function() {
                /*
                 * selector
                 *   : simple_selector_sequence [ combinator simple_selector_sequence ]*
                 *   ;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

Function `get` has 42 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    get: function(channel) {

        var tokenInfo   = this._tokenData,
            i           =0,
            token,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

Function `_media` has 42 lines of code (exceeds 25 allowed). Consider refactoring.
Open

            _media: function() {
                /*
                 * media
                 *   : MEDIA_SYM S* media_query_list S* '{' S* ruleset* '}' S*
                 *   ;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

Function `result` has 42 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    var result = new Matcher(function(expression) {
        var seen = [], max = 0, pass = 0;
        var success = function(matchCount) {
            if (pass === 0) {
                max = Math.max(matchCount, max);

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

},{"./Colors":1,"./Combinator":2,"./Matcher":3,"./MediaFeature":4,"./MediaQuery":5,"./Parser":6,"./PropertyName":8,"./PropertyValue":9,"./PropertyValuePart":11,"./Selector":13,"./SelectorPart":14,"./SelectorSubPart":15,"./Specificity":16,"./TokenStream":17,"./Tokens":18,"./ValidationError":20}],23:[function(require,module,exports){
"use strict";

module.exports = EventTarget;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

Specificity.calculate = function(selector) {

    var i, len,
        part,
        b=0, c=0, d=0;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    stringToken: function(first, startLine, startCol) {
        var delim   = first,
            string  = first,
            reader  = this._reader,
            tt      = Tokens.STRING,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            classes = {};

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

Function `_ruleset` has 40 lines of code (exceeds 25 allowed). Consider refactoring.
Open

            _ruleset: function() {
                /*
                 * ruleset
                 *   : selectors_group
                 *     '{' S* declaration? [ ';' S* declaration? ]* '}' S*

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

Function `_readDeclarations` has 40 lines of code (exceeds 25 allowed). Consider refactoring.
Open

            _readDeclarations: function(checkStart, readMargins) {
                /*
                 * Reads the pattern
                 * S* '{' S* declaration [ ';' S* declaration ]* '}' S*
                 * or

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _media_query: function() {
                /*
                 * media_query
                 *   : [ONLY | NOT]? S* media_type S* [ AND S* expression ]*
                 *   | expression [ AND S* expression ]*

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _declaration: function() {

                /*
                 * declaration
                 *   : property ':' S* expr prio?

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _keyframes: function() {

                /*
                 * keyframes:
                 *   : KEYFRAMES_SYM S* keyframe_name S* '{' S* keyframe_rule* '}' {

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    importantToken: function(first, startLine, startCol) {
        var reader      = this._reader,
            important   = first,
            tt          = Tokens.CHAR,
            temp,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

},{"../util/SyntaxUnit":26,"./Parser":6}],10:[function(require,module,exports){
"use strict";

module.exports = PropertyValueIterator;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    readEscape: function(first, unescape) {
        var reader  = this._reader,
            cssEscape = first || "",
            i       = 0,
            c       = reader.peek();

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            gradients;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _page: function() {
                /*
                 * page:
                 *    PAGE_SYM S* IDENT? pseudo_page? S*
                 *    '{' S* [ declaration | margin ]? [ ';' S* [ declaration | margin ]? ]* '}' S*

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _function: function() {

                /*
                 * function
                 *   : FUNCTION S* expr ')' S*

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _negation_arg: function() {
                /*
                 * negation_arg
                 *   : type_selector | universal | HASH | class | attrib | pseudo
                 *   ;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    formatResults: function(results, filename, options) {
        "use strict";
        var messages = results.messages,
            output = "";
        options = options || {};

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            fontFaceRule = false,
            firstSrc = true,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    formatResults: function(results, filename/*, options*/) {
        "use strict";

        var messages = results.messages,
            output = [],

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _supports: function(emit) {
                /*
                 * supports_rule
                 *  : SUPPORTS_SYM S* supports_condition S* group_rule_body
                 *  ;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";

        var rule = this;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    function updateValues(part) {

        var i, j, len, num,
            elementName = part.elementName ? part.elementName.text : "",
            modifier;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this;
        parser.addListener("startrule", function(event) {
            var selectors = event.selectors,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this,
            properties;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _ie_function: function() {

                /* (My own extension)
                 * ie_function
                 *   : IE_FUNCTION S* IDENT '=' term [S* ','? IDENT '=' term]+ ')' S*

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _attrib: function() {
                /*
                 * attrib
                 *   : '[' S* [ namespace_prefix ]? IDENT S*
                 *         [ [ PREFIXMATCH |

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

        function endRule() {

            var display = properties.display ? properties.display.value : null;
            if (display) {
                switch (display) {

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _namespace: function(emit) {
                /*
                 * namespace
                 *   : NAMESPACE_SYM S* [namespace_prefix S*]? [STRING|URI] S* ';' S*
                 */

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    unicodeRangeToken: function(first, startLine, startCol) {
        var reader  = this._reader,
            value   = first,
            temp,
            tt      = Tokens.CHAR;

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    identOrFunctionToken: function(first, startLine, startCol) {
        var reader  = this._reader,
            ident   = this.readName(first),
            tt      = Tokens.IDENT,
            uriFns  = ["url(", "url-prefix(", "domain("],

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    init: function(parser, reporter) {
        "use strict";
        var rule = this;
        parser.addListener("startrule", function(event) {
            var selectors = event.selectors,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

            _pseudo: function() {

                /*
                 * pseudo
                 *   : ':' ':'? [ IDENT | functional_pseudo ]

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    readURI: function(first) {
        var reader  = this._reader,
            uri     = first,
            inner   = "",
            c       = reader.peek();

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

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

    numberToken: function(first, startLine, startCol) {
        var reader  = this._reader,
            value   = this.readNumber(first),
            ident,
            tt      = Tokens.NUMBER,

Found in wp-includes/js/codemirror/csslint.js - About 1 hr to fix

Avoid deeply nested control flow statements.
Open

                            if (classCount > 1){
                                reporter.report("Adjoining classes: "+selectors[i].text, part.line, part.col, rule);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (!lastProperty || (lastProperty.property.text.toLowerCase() !== name || lastProperty.colorType !== "compat")) {
                                reporter.report("Fallback " + name + " (hex or RGB) should precede " + colorType + " " + name + ".", event.line, event.col, rule);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (!(prop === "padding" && value.parts.length === 2 && value.parts[0].value === 0)) {
                                reporter.report("Using height with " + prop + " can sometimes make elements larger than you expect.", properties[prop].line, properties[prop].col, rule);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                                if (combinator !== null) {
                                    this._unexpectedToken(tokenStream.LT(1));
                                }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                        if (unary === null) {
                            line = tokenStream.LT(1).startLine;
                            col = tokenStream.LT(1).startCol;
                        }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                        if (value === null) {

                            /*
                             * This checks for alpha(opacity=0) style of IE
                             * functions. IE_FUNCTION only presents progid: style.

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                                if (combinator !== null) {
                                    selector.push(combinator);
                                } else {
                                    selector.push(ws);
                                }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (modifier.type === "class") {
                                classCount++;
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (CSSLint.Util.indexOf(propertyGroups[prop].actual, name.text) === -1) {
                                propertyGroups[prop].actual.push(name.text);
                                propertyGroups[prop].actualNodes.push(name);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (/([^\)]+)\(/.test(parts[i])) {
                                colorType = RegExp.$1.toUpperCase();
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                        if (unary === null) {
                            line = token.startLine;
                            col = token.startCol;
                        }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                        if (temp.length === 1) {
                            reader.reset();
                        } else {
                            value += temp;
                        }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (modifier.type === "id") {
                                idCount++;
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (!propertyGroups[prop]) {
                                propertyGroups[prop] = {
                                    full: variations.slice(0),
                                    actual: [],
                                    actualNodes: []

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (modifier.type === "attribute") {
                                if (/([~\|\^\$\*]=)/.test(modifier)) {
                                    reporter.report("Attribute selectors with " + RegExp.$1 + " are slow!", modifier.line, modifier.col, rule);
                                }
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (part.elementName && modifier.type === "id") {
                                reporter.report("Element (" + part + ") is overqualified, just use " + modifier + " without element name.", part.line, part.col, rule);
                            } else if (modifier.type === "class") {

                                if (!classes[modifier]) {

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (CSSLint.Util.indexOf(actual, item) === -1) {
                                propertiesSpecified = (actual.length === 1) ? actual[0] : (actual.length === 2) ? actual.join(" and ") : actual.join(", ");
                                reporter.report("The property " + item + " is compatible with " + propertiesSpecified + " and should be included as well.", value.actualNodes[0].line, value.actualNodes[0].col, rule);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (!(prop === "padding" && value.parts.length === 2 && value.parts[1].value === 0)) {
                                reporter.report("Using width with " + prop + " can sometimes make elements larger than you expect.", properties[prop].line, properties[prop].col, rule);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

Avoid deeply nested control flow statements.
Open

                            if (modifier.type === "attribute" && (!part.elementName || part.elementName === "*")) {
                                reporter.report(rule.desc, part.line, part.col, rule);
                            }

Found in wp-includes/js/codemirror/csslint.js - About 45 mins to fix

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

function clone(parent, circular, depth, prototype, includeNonEnumerable) {

Found in wp-includes/js/codemirror/csslint.js - About 35 mins to fix

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

function MediaQuery(modifier, mediaType, features, line, col) {

Found in wp-includes/js/codemirror/csslint.js - About 35 mins to fix

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

function SelectorPart(elementName, modifiers, text, line, col) {

Found in wp-includes/js/codemirror/csslint.js - About 35 mins to fix

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

    createToken: function(tt, value, startLine, startCol, options) {

Found in wp-includes/js/codemirror/csslint.js - About 35 mins to fix

Avoid too many `return` statements within this function.
Open

        return allChildren[index];

Found in wp-includes/js/codemirror/csslint.js - About 30 mins to fix

Avoid too many `return` statements within this function.
Open

    return child;

Found in wp-includes/js/codemirror/csslint.js - About 30 mins to fix

Avoid too many `return` statements within this function.
Open

        return m;

Found in wp-includes/js/codemirror/csslint.js - About 30 mins to fix

Avoid too many `return` statements within this function.
Open

            return m.braces(+min, +max);

Found in wp-includes/js/codemirror/csslint.js - About 30 mins to fix

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

                        do {

                            if (this._readWhitespace()) {
                                functionText += tokenStream.token().value;
                            }

Found in wp-includes/js/codemirror/csslint.js and 1 other location - About 1 day to fix

Read up
Read up

wp-includes/js/codemirror/csslint.js on lines 2785..2809

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

Tuning

This issue has a mass of 70.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 70.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 70.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 70.

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

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

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

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

Refactorings

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

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

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:

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

Tuning

This issue has a mass of 59.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 59.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 58.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 58.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 54.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 54.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 53.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 53.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 53.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 53.

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

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

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

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

Refactorings

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:

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

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:

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

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:

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

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:

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

Tuning

This issue has a mass of 50.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 49.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 49.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 49.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 49.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 48.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 48.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 48.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 48.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 48.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 48.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 47.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 47.

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

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

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

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

Refactorings

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:

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

Tuning

This issue has a mass of 47.

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

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

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

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

Refactorings

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:

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

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

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:

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

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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.

WordPress/WordPress

Summary

Maintainability

Test Coverage

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

Cognitive Complexity

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

Further reading

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

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

File csslint.js has 6554 lines of code (exceeds 250 allowed). Consider refactoring. Open

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Function `CSSLint` has a Cognitive Complexity of 2488 (exceeds 5 allowed). Consider refactoring.
Open

Function `CSSLint` has 6552 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `parserlib` has 4285 lines of code (exceeds 25 allowed). Consider refactoring.
Open

File `csslint.js` has 6554 lines of code (exceeds 250 allowed). Consider refactoring.
Open

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

Function `prototype` has 1458 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

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

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

Function `clone` has 184 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

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

Function `init` has 152 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `CSSLint` has 151 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

Function `clone` has 132 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `PropertyValuePart` has 128 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `_clone` has 116 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `_stylesheet` has 112 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `init` has 102 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

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

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

Function `init` has 78 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

Function `many` has 72 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

Function `_document` has 59 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `_simple_selector_sequence` has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `init` has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `init` has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

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

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

Function `get` has 42 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `_media` has 42 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `result` has 42 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

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

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

Function `_ruleset` has 40 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `_readDeclarations` has 40 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open