BallStateCBER/datacenter-plugin-cakephp3

File less-1.7.3.js has 6224 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*!
 * Less - Leaner CSS v1.7.3
 * http://lesscss.org
 *
 * Copyright (c) 2009-2014, Alexis Sellier <self@cloudhead.net>

Function Parser has 1397 lines of code (exceeds 25 allowed). Consider refactoring.

Open

less.Parser = function Parser(env) {
    var input,       // LeSS input string
        i,           // current index in `input`
        j,           // current chunk
        saveStack = [],   // holds state for backtracking

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

Open

        parse: function (str, callback, additionalData) {
            var root, line, lines, error = null, globalVars, modifyVars, preText = "";

            i = j = currentPos = furthest = 0;

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

Open

    eval: function (env) {
        var thisSelectors = this.selectors, selectors, 
            selCnt, selector, i, defaultFunc = tree.defaultFunc, hasOnePassingSelector = false;

        if (thisSelectors && (selCnt = thisSelectors.length)) {

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

Open

    eval: function (env) {
        var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound, rule,
            candidates = [], candidate, conditionResult = [], defaultFunc = tree.defaultFunc,
            defaultResult, defNone = 0, defTrue = 1, defFalse = 2, count, originalRuleset; 

Function args has 93 lines of code (exceeds 25 allowed). Consider refactoring.

Open

                args: function (isCall) {
                    var parsers = parser.parsers, entities = parsers.entities,
                        returner = { args:null, variadic: false },
                        expressions = [], argsSemiColon = [], argsComma = [],
                        isSemiColonSeperated, expressionContainsNamed, name, nameLoop, value, arg;

Function errorHTML has 87 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function errorHTML(e, rootHref) {
    var id = 'less-error-message:' + extractId(rootHref || "");
    var template = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>';
    var elem = document.createElement('div'), timer, content, errors = [];
    var filename = e.filename || rootHref;

Function toCSS has 87 lines of code (exceeds 25 allowed). Consider refactoring.

Open

            root.toCSS = (function (evaluate) {
                return function (options, variables) {
                    options = options || {};
                    var evaldRoot,
                        css,

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

Open

    joinSelector: function (paths, context, selector) {

        var i, j, k, 
            hasParentSelector, newSelectors, el, sel, parentSel, 
            newSelectorPath, afterParentJoin, newJoinedSelector, 

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

Open

    genCSS: function (env, output) {
        var i, j,
            ruleNodes = [],
            rulesetNodes = [],
            rulesetNodeCnt,

Function svg-gradient has 66 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    "svg-gradient": function(direction) {

        function throwArgumentDescriptor() {
            throw { type: "Argument", message: "svg-gradient expects direction, start_color [start_position], [color position,]..., end_color [end_position]" };
        }

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

Open

    evalParams: function (env, mixinEnv, args, evaldArguments) {
        /*jshint boss:true */
        var frame = new(tree.Ruleset)(null, null),
            varargs, arg,
            params = this.params.slice(0),

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

Open

        visitRuleset: function (rulesetNode, visitArgs) {
            var rule, rulesets = [];
            if (rulesetNode.firstRoot) {
                this.checkPropertiesInRoot(rulesetNode.rules);
            }

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

Open

            directive: function () {
                var index = i, name, value, rules, nonVendorSpecificName,
                    hasIdentifier, hasExpression, hasUnknown, hasBlock = true;

                if (input.charAt(i) !== '@') { return; }

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

Open

        visitImport: function (importNode, visitArgs) {
            var importVisitor = this,
                evaldImportNode,
                inlineCSS = importNode.options.inline;
            

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

Open

        extendSelector:function (matches, selectorPath, replacementSelector) {

            //for a set of matches, replace each match with the replacement selector

            var currentSelectorPathIndex = 0,

Function data-uri has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    "data-uri": function(mimetypeNode, filePathNode) {

        if (typeof window !== 'undefined') {
            return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
        }

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

Open

        findMatch: function (extend, haystackSelectorPath) {
            //
            // look through the haystack selector path to try and find the needle - extend.selector
            // returns an array of selector matches that can then be replaced
            //

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

Open

        _mergeRules: function (rules) {
            if (!rules) { return; }

            var groups = {},
                parts,

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

Open

function loadFile(originalHref, currentFileInfo, callback, env, modifyVars) {

    if (currentFileInfo && currentFileInfo.currentDirectory && !/^([a-z-]+:)?\//.test(originalHref)) {
        originalHref = currentFileInfo.currentDirectory + originalHref;
    }

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

Open

        doExtendChaining: function (extendsList, extendsListTarget, iterationCount) {
            //
            // chaining is different from normal extension.. if we extend an extend then we are not just copying, altering and pasting
            // the selector we would do normally, but we are also adding an extend with the same target selector
            // this means this new extend can then go and alter other extends

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

Open

function createCSS(styles, sheet, lastModified) {
    // Strip the query-string
    var href = sheet.href || '';

    // If there is no title set, use the filename, minus the extension

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

Open

    tree.sourceMapOutput.prototype.add = function(chunk, fileInfo, index, mapLines) {

        //ignore adding empty strings
        if (!chunk) {
            return;

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

Open

    _minmax: function (isMin, args) {
        args = Array.prototype.slice.call(args);
        switch(args.length) {
            case 0: throw { type: "Argument", message: "one or more arguments required" };
        }

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

Open

    eval: function (env) {
        var result,
            that = this,
            context = {};

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

Open

function extractUrlParts(url, baseUrl) {
    // urlParts[1] = protocol&hostname || /
    // urlParts[2] = / if path relative to host base
    // urlParts[3] = directories
    // urlParts[4] = filename

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

Open

    cancel: function () {
        var counter = {}, atomicUnit, i, backup;

        for (i = 0; i < this.numerator.length; i++) {
            atomicUnit = this.numerator[i];

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

Open

        isElementValuesEqual: function(elementValue1, elementValue2) {
            if (typeof elementValue1 === "string" || typeof elementValue2 === "string") {
                return elementValue1 === elementValue2;
            }
            if (elementValue1 instanceof tree.Attribute) {

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

Open

        visit: function(node) {
            if (!node) {
                return node;
            }

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

Open

function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {

    var env = new less.tree.parseEnv(less);
    env.mime = sheet.type;

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

Open

    eval: function (env) {
        var strictMathBypass = false, name = this.name, evaldValue;
        if (typeof name !== "string") {
            // expand 'primitive' name directly to get
            // things faster (~10% for benchmark.less):

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

Open

        visitRuleset: function (rulesetNode, visitArgs) {
            if (rulesetNode.root) {
                return;
            }

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

Open

            ruleset: function () {
                var selectors, s, rules, debugInfo;

                save();

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

Open

                definition: function () {
                    var name, params = [], match, ruleset, cond, variadic = false;
                    if ((input.charAt(i) !== '.' && input.charAt(i) !== '#') ||
                        peek(/^[^{]*\}/)) {
                        return;

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

Open

function doXHR(url, type, callback, errback) {
    var xhr = getXMLHttpRequest();
    var async = isFileProtocol ? less.fileAsync : less.async;

    if (typeof(xhr.overrideMimeType) === 'function') {

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

Open

    convertTo: function (conversions) {
        var value = this.value, unit = this.unit.clone(),
            i, groupName, group, targetUnit, derivedConversions = {}, applyUnit;

        if (typeof conversions === 'string') {

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

Open

    tree.sourceMapOutput.prototype.toCSS = function(env) {
        this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });

        if (this._outputSourceFiles) {
            for(var filename in this._contentsMap) {

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

Open

    eval: function (env) {
        if (!env.mediaBlocks) {
            env.mediaBlocks = [];
            env.mediaPath = [];
        }

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

Open

        push: function (path, currentFileInfo, importOptions, callback) {
            var parserImports = this;
            this.queue.push(path);

            var fileParsedFunc = function (e, root, fullPath) {

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

Open

            rule: function (tryAnonymous) {
                var name, value, startOfRule = i, c = input.charAt(startOfRule), important, merge, isVariable;

                if (c === '.' || c === '#' || c === '&') { return; }

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

Open

                call: function () {
                    var s = input.charAt(i), important = false, index = i, elemIndex,
                        elements, elem, e, c, args;

                    if (s !== '.' && s !== '#') { return; }

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

Open

function loadStyles(modifyVars) {
    var styles = document.getElementsByTagName('style'),
        style;
    for (var i = 0; i < styles.length; i++) {
        style = styles[i];

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

Open

    eval: function (env) {
        var a = this.lvalue.eval(env),
            b = this.rvalue.eval(env);

        var i = this.index, result;

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

Open

            ruleProperty: function () {
                var c = current, name = [], index = [], length = 0, s, k;

                function match(re) {
                    var a = re.exec(c);

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

Open

    eval: function (env) {
        var variable, name = this.name;

        if (name.indexOf('@@') === 0) {
            name = '@' + new(tree.Variable)(name.slice(1)).eval(env).value;

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

Open

tree.Rule = function (name, value, important, merge, index, currentFileInfo, inline) {

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

Open

tree.mixin.Definition = function (name, params, rules, condition, variadic, frames) {

Avoid deeply nested control flow statements.

Open

                        if ((!(mixin instanceof tree.mixin.Definition)) && mixin === (env.frames[f].originalRuleset || env.frames[f])) {
                            isRecursive = true;
                            break;
                        }

Avoid deeply nested control flow statements.

Open

                            } else if (!isCall) {
                                name = nameLoop = val.name;
                                value = null;
                            }

Avoid deeply nested control flow statements.

Open

                            if (potentialMatch.finished) {
                                potentialMatch.length = needleElements.length;
                                potentialMatch.endPathIndex = haystackSelectorIndex;
                                potentialMatch.endPathElementIndex = hackstackElementIndex + 1; // index after end of match
                                potentialMatches.length = 0; // we don't allow matches to overlap, so start matching again

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

Open

tree.Directive = function (name, value, rules, index, currentFileInfo, debugInfo) {

Avoid deeply nested control flow statements.

Open

                        if (!evaldArguments[j] && name === params[j].name) {
                            evaldArguments[j] = arg.value.eval(env);
                            frame.prependRule(new(tree.Rule)(name, arg.value.eval(env)));
                            isNamedFound = true;
                            break;

Avoid deeply nested control flow statements.

Open

                        for (k = 0; k < context.length; k++) {
                            parentSel = context[k];
                            // We need to put the current selectors
                            // then join the last selector's elements on to the parents selectors

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

Open

tree.Selector = function (elements, extendList, condition, index, currentFileInfo, isReferenced) {

Avoid deeply nested control flow statements.

Open

                                    if ((cc2 <= 13) && ((cc2 == 10) || (cc2 == 13))) { break; }

Avoid deeply nested control flow statements.

Open

                                if (parserCurrentIndex == len - 1) {
                                    return fail("missing closing `*/`", currentChunkStartIndex);
                                }

Avoid deeply nested control flow statements.

Open

                    for (i = 0; i < -count; i++) {
                        this.denominator.push(atomicUnit);
                    }

Avoid deeply nested control flow statements.

Open

                            if (!(mixin instanceof tree.mixin.Definition)) {
                                originalRuleset = mixin.originalRuleset || mixin;
                                mixin = new tree.mixin.Definition("", [], mixin.rules, null, false);
                                mixin.originalRuleset = originalRuleset;
                            }

Avoid deeply nested control flow statements.

Open

                                    if (fullPath in importVisitor.onceFileDetectionMap) {
                                        return true;
                                    }

Avoid deeply nested control flow statements.

Open

                        if (!(subRule instanceof tree.Rule) || !subRule.variable) {
                            rsRules.splice(++i, 0, subRule);
                        }

Avoid deeply nested control flow statements.

Open

                                    if (parserCurrentIndex == len - 1) {
                                        return fail("unescaped `\\`");
                                    }

Avoid deeply nested control flow statements.

Open

                                for (parserCurrentIndex = parserCurrentIndex + 2; parserCurrentIndex < len - 1; parserCurrentIndex++) {
                                    cc2 = input.charCodeAt(parserCurrentIndex);
                                    if (cc2 == 125) { lastMultiCommentEndBrace = parserCurrentIndex; }
                                    if (cc2 != 42) { continue; }
                                    if (input.charCodeAt(parserCurrentIndex + 1) == 47) { break; }

Avoid deeply nested control flow statements.

Open

                                if ($char(";") && !isSemiColonSeperated) {
                                    isSemiColonSeperated = true;
                                }

Avoid deeply nested control flow statements.

Open

                        for (i = 0; i < rules.length; i++) {
                            rule = rules[i];
                            if (rule.markReferenced) {
                                rule.markReferenced();
                            }

Avoid deeply nested control flow statements.

Open

                        if (mixin.matchCondition) { 
                            for (f = 0; f < 2; f++) {
                                defaultFunc.value(f);
                                conditionResult[f] = mixin.matchCondition(args, env);
                            }

Avoid deeply nested control flow statements.

Open

                                    if (isSemiColonSeperated) {
                                        error("Cannot mix ; and , as delimiter types");
                                    }

Avoid deeply nested control flow statements.

Open

                        if (sel.length > 0) {
                            sel[0].elements = sel[0].elements.slice(0);
                            sel[0].elements.push(new(tree.Element)(el.combinator, '', el.index, el.currentFileInfo));
                        }

Avoid deeply nested control flow statements.

Open

                            if (potentialMatch.finished &&
                                (!extend.allowAfter && (hackstackElementIndex+1 < hackstackSelector.elements.length || haystackSelectorIndex+1 < haystackSelectorPath.length))) {
                                potentialMatch = null;
                            }

Avoid deeply nested control flow statements.

Open

                                    if (isCall) {
                                        error("could not understand value for named argument");
                                    } else {
                                        restore();
                                        returner.args = [];

Consider simplifying this complex logical expression.

Open

                    if (!value) {
                        // prefer to try to parse first if its a variable or we are compressing
                        // but always fallback on the other one
                        value = !tryAnonymous && (env.compress || isVariable) ?
                            (this.value() || this.anonymousValue()) :

Consider simplifying this complex logical expression.

Open

                if (m) {
                    isSpaced = isWhitespace(input, i - 1);
                    while (true) {
                        op = $re(/^[-+]\s+/) || (!isSpaced && ($char('+') || $char('-')));
                        if (!op) {

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

Open

function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {

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

Open

tree.Condition = function (op, l, r, i, negate) {

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

Open

    tree.importVisitor = function(importer, finish, evalEnv, onceFileDetectionMap, recursionDetector) {

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

Open

tree.Quoted = function (str, content, escaped, index, currentFileInfo) {

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

Open

function loadFile(originalHref, currentFileInfo, callback, env, modifyVars) {

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

Open

tree.Import = function (path, features, options, index, currentFileInfo) {

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

Open

tree.mixin.Call = function (elements, args, index, currentFileInfo, important) {

Avoid too many return statements within this function.

Open

            return -1;

Avoid too many return statements within this function.

Open

                return true;

Avoid too many return statements within this function.

Open

            return match.length === 1 ? match[0] : match;

Avoid too many return statements within this function.

Open

                                return fail("unmatched `/*`");

Avoid too many return statements within this function.

Open

                        return fail("missing closing `}`", lastOpening);

Avoid too many return statements within this function.

Open

                    return false;

Avoid too many return statements within this function.

Open

                            return false;

Avoid too many return statements within this function.

Open

                            return fail("unmatched `" + String.fromCharCode(cc) + "`", currentChunkStartIndex);

Avoid too many return statements within this function.

Open

                        return fail("missing closing `}` or `*/`", lastOpening);

Avoid too many return statements within this function.

Open

                                    return fail("missing closing `*/`", currentChunkStartIndex);

Avoid too many return statements within this function.

Open

                    if (name) { return new(tree.Call)(name, args, index, env.currentFileInfo); }

Avoid too many return statements within this function.

Open

                        return false;

Avoid too many return statements within this function.

Open

            return false;

Avoid too many return statements within this function.

Open

                    return fail("missing closing `)`", lastOpeningParen);

Avoid too many return statements within this function.

Open

                return elementValue1 === elementValue2;

Avoid too many return statements within this function.

Open

                return chunks;

Avoid too many return statements within this function.

Open

        return true;

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

Open

    tree.colors = {
        'aliceblue':'#f0f8ff',
        'antiquewhite':'#faebd7',
        'aqua':'#00ffff',
        'aquamarine':'#7fffd4',

• Read up
  Read up

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

Open

    var errorline = function (e, i, classname) {
        if (e.extract[i] !== undefined) {
            errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
                .replace(/\{class\}/, classname)
                .replace(/\{content\}/, e.extract[i]));

• Read up
  Read up

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

Open

    var errorline = function (e, i, classname) {
        if (e.extract[i] !== undefined) {
            errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
                .replace(/\{class\}/, classname)
                .replace(/\{content\}/, e.extract[i]));

• Read up
  Read up

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

Open

        visitDirective: function (directiveNode, visitArgs) {
            var newAllExtends = directiveNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length-1]);
            newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, directiveNode.allExtends));
            this.allExtendsStack.push(newAllExtends);
        },

• Read up
  Read up

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

Open

        visitMedia: function (mediaNode, visitArgs) {
            var newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length-1]);
            newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));
            this.allExtendsStack.push(newAllExtends);
        },

• Read up
  Read up

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

Open

        } else if (op === '/') {
            unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
            unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
            unit.cancel();
        }

• Read up
  Read up

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

Open

        } else if (op === '*') {
            unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
            unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
            unit.cancel();
        } else if (op === '/') {

• Read up
  Read up

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

Open

            switch (max) {
                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
                case g: h = (b - r) / d + 2;               break;
                case b: h = (r - g) / d + 4;               break;
            }

• Read up
  Read up

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

Open

            switch(max){
                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
                case g: h = (b - r) / d + 2; break;
                case b: h = (r - g) / d + 4; break;
            }

• Read up
  Read up

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

Open

        for(var i = 0; i < this.args.length; i++) {
            this.args[i].genCSS(env, output);
            if (i + 1 < this.args.length) {
                output.add(", ");
            }

• Read up
  Read up

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

Open

        for(var i = 0; i < this.value.length; i++) {
            this.value[i].genCSS(env, output);
            if (i + 1 < this.value.length) {
                output.add(" ");
            }

• Read up
  Read up

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

Open

        for (i = 0; i < this.denominator.length; i++) {
            atomicUnit = this.denominator[i];
            if (!backup) {
                backup = atomicUnit;
            }

• Read up
  Read up

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

Open

        for (i = 0; i < this.numerator.length; i++) {
            atomicUnit = this.numerator[i];
            if (!backup) {
                backup = atomicUnit;
            }

• Read up
  Read up

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

Open

    accept: function (visitor) {
        if (this.selector) {
            this.selector = visitor.visit(this.selector);
        }
        if (this.arguments) {

• Read up
  Read up

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

Open

    accept: function (visitor) {
        if (this.features) {
            this.features = visitor.visit(this.features);
        }
        if (this.rules) {

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

    lighten: function (color, amount) {
        var hsl = color.toHSL();

        hsl.l += amount.value / 100;
        hsl.l = clamp(hsl.l);

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

    fade: function (color, amount) {
        var hsl = color.toHSL();

        hsl.a = amount.value / 100;
        hsl.a = clamp(hsl.a);

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

    desaturate: function (color, amount) {
        var hsl = color.toHSL();

        hsl.s -= amount.value / 100;
        hsl.s = clamp(hsl.s);

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

    darken: function (color, amount) {
        var hsl = color.toHSL();

        hsl.l -= amount.value / 100;
        hsl.l = clamp(hsl.l);

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

    fadein: function (color, amount) {
        var hsl = color.toHSL();

        hsl.a += amount.value / 100;
        hsl.a = clamp(hsl.a);

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

    fadeout: function (color, amount) {
        var hsl = color.toHSL();

        hsl.a -= amount.value / 100;
        hsl.a = clamp(hsl.a);

• Read up
  Read up

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

Open

                    path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));

• Read up
  Read up

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

Open

tree.Anonymous = function (value, index, currentFileInfo, mapLines) {
    this.value = value;
    this.index = index;
    this.mapLines = mapLines;
    this.currentFileInfo = currentFileInfo;

• Read up
  Read up

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

Open

tree.Call = function (name, args, index, currentFileInfo) {
    this.name = name;
    this.args = args;
    this.index = index;
    this.currentFileInfo = currentFileInfo;

• Read up
  Read up

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

Open

                path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));

• Read up
  Read up

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

Open

        var r = this.rgb[0] / 255,
            g = this.rgb[1] / 255,
            b = this.rgb[2] / 255,
            a = this.alpha;

• Read up
  Read up

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

Open

        var r = this.rgb[0] / 255,
            g = this.rgb[1] / 255,
            b = this.rgb[2] / 255,
            a = this.alpha;

• Read up
  Read up

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

Open

        for (i = 0; i < this.denominator.length; i++) {
            this.denominator[i] = callback(this.denominator[i], true);
        }

• Read up
  Read up

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

Open

        for (i = 0; i < this.numerator.length; i++) {
            this.numerator[i] = callback(this.numerator[i], false);
        }

• Read up
  Read up

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

Open

        if (isOneFound) {
            throw { type:    'Runtime',
                    message: 'No matching definition was found for `' + this.format(args) + '`',
                    index:   this.index, filename: this.currentFileInfo.filename };
        } else {

• Read up
  Read up

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

Open

                    if ((count[defTrue] + count[defFalse]) > 1) {
                        throw { type: 'Runtime',
                            message: 'Ambiguous use of `default()` found when matching for `'
                                + this.format(args) + '`',
                            index: this.index, filename: this.currentFileInfo.filename };

• Read up
  Read up

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

Open

        for (i = 0; i < rules.length; i++) {
            if (rules[i].markReferenced) {
                rules[i].markReferenced();
            }
        }

• Read up
  Read up

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

Open

            for (i = 0; i < rules.length; i++) {
                if (rules[i].markReferenced) {
                    rules[i].markReferenced();
                }
            }

• Read up
  Read up

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

Open

tree.JavaScript = function (string, index, escaped) {
    this.escaped = escaped;
    this.expression = string;
    this.index = index;
};

• Read up
  Read up

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

Open

tree.URL = function (val, currentFileInfo, isEvald) {
    this.value = val;
    this.currentFileInfo = currentFileInfo;
    this.isEvald = isEvald;
};

• Read up
  Read up

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

Open

tree.Attribute = function (key, op, value) {
    this.key = key;
    this.op = op;
    this.value = value;
};

• Read up
  Read up

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

Open

    _outputMap: {
        ''  : '',
        ' ' : ' ',
        ':' : ' :',
        '+' : ' + ',

• Read up
  Read up

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

Open

    _outputMapCompressed: {
        ''  : '',
        ' ' : ' ',
        ':' : ' :',
        '+' : '+',

• Read up
  Read up

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

Open

        if (this.value.genCSS) {
            this.value.genCSS(env, output);
        } else {
            output.add(this.value);
        }

• Read up
  Read up

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

Open

        if (this.value.genCSS) {
            this.value.genCSS(env, output);
        } else {
            output.add(this.value);
        }

• Read up
  Read up

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

Open

    genCSS: function (env, output) {
        output.add('(');
        this.value.genCSS(env, output);
        output.add(')');
    },

• Read up
  Read up

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

Open

    genCSS: function (env, output) {
        output.add("url(");
        this.value.genCSS(env, output);
        output.add(")");
    },

• Read up
  Read up

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

Open

                if (!evald.splice) {
                    out.push(evald);
                } else if (evald.length) {
                    this.flatten(evald, out);
                }

• Read up
  Read up

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

Open

                    if (!nestedItem.splice) {
                        out.push(nestedItem);
                    } else if (nestedItem.length) {
                        this.flatten(nestedItem, out);
                    }

• Read up
  Read up

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

Open

        if (this.params && this.params.length) {
            this.params = visitor.visitArray(this.params);
        }

• Read up
  Read up

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

Open

        if (this.rules && this.rules.length) {
            this.rules = visitor.visitArray(this.rules);
        }

• Read up
  Read up

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

Open

    accept: function (visitor) {
        if (this.args) {
            this.args = visitor.visitArray(this.args);
        }
    },

• Read up
  Read up

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

Open

    accept: function (visitor) {
        if (this.value) {
            this.value = visitor.visitArray(this.value);
        }
    },

• Read up
  Read up

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

Open

    accept: function (visitor) {
        if (this.value) {
            this.value = visitor.visitArray(this.value);
        }
    },

• Read up
  Read up