less 2.5.1 → 2.6.1

package/lib/less/contexts.js

@@ -30,7 +30,6 @@ var parseCopyProperties = [
     // context
     'processImports',   // option & context - whether to process imports. if false then imports will not be imported.
                         // Used by the import manager to stop multiple import visitors being created.
-    'reference',        // Used to indicate that the contents are imported by reference
     'pluginManager'     // Used as the plugin manager for the session
 ];
 

package/lib/less/functions/color.js

@@ -43,6 +43,9 @@ colorFunctions = {
         return colorFunctions.hsla(h, s, l, 1.0);
     },
     hsla: function (h, s, l, a) {
+
+        var m1, m2;
+
         function hue(h) {
             h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
             if (h * 6 < 1) {
@@ -62,8 +65,8 @@ colorFunctions = {
         h = (number(h) % 360) / 360;
         s = clamp(number(s)); l = clamp(number(l)); a = clamp(number(a));
 
-        var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
-        var m1 = l * 2 - m2;
+        m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
+        m1 = l * 2 - m2;
 
         return colorFunctions.rgba(hue(h + 1 / 3) * 255,
             hue(h)       * 255,

package/lib/less/functions/math-helper.js

@@ -0,0 +1,16 @@
+var Dimension = require("../tree/dimension");
+
+var MathHelper = function() {
+};
+MathHelper._math = function (fn, unit, n) {
+    if (!(n instanceof Dimension)) {
+        throw { type: "Argument", message: "argument must be a number" };
+    }
+    if (unit == null) {
+        unit = n.unit;
+    } else {
+        n = n.unify();
+    }
+    return new Dimension(fn(parseFloat(n.value)), unit);
+};
+module.exports = MathHelper;

package/lib/less/functions/math.js

@@ -1,5 +1,5 @@
-var Dimension = require("../tree/dimension"),
-    functionRegistry = require("./function-registry");
+var functionRegistry = require("./function-registry"),
+    mathHelper = require("./math-helper.js");
 
 var mathFunctions = {
     // name,  unit
@@ -15,27 +15,15 @@ var mathFunctions = {
     acos:  "rad"
 };
 
-function _math(fn, unit, n) {
-    if (!(n instanceof Dimension)) {
-        throw { type: "Argument", message: "argument must be a number" };
-    }
-    if (unit == null) {
-        unit = n.unit;
-    } else {
-        n = n.unify();
-    }
-    return new Dimension(fn(parseFloat(n.value)), unit);
-}
-
 for (var f in mathFunctions) {
     if (mathFunctions.hasOwnProperty(f)) {
-        mathFunctions[f] = _math.bind(null, Math[f], mathFunctions[f]);
+        mathFunctions[f] = mathHelper._math.bind(null, Math[f], mathFunctions[f]);
     }
 }
 
 mathFunctions.round = function (n, f) {
     var fraction = typeof f === "undefined" ? 0 : f.value;
-    return _math(function(num) { return num.toFixed(fraction); }, null, n);
+    return mathHelper._math(function(num) { return num.toFixed(fraction); }, null, n);
 };
 
 functionRegistry.addMultiple(mathFunctions);

package/lib/less/functions/number.js

@@ -1,6 +1,7 @@
 var Dimension = require("../tree/dimension"),
     Anonymous = require("../tree/anonymous"),
-    functionRegistry = require("./function-registry");
+    functionRegistry = require("./function-registry"),
+    mathHelper = require("./math-helper.js");
 
 var minMax = function (isMin, args) {
     args = Array.prototype.slice.call(args);
@@ -71,6 +72,10 @@ functionRegistry.addMultiple({
         return new Dimension(Math.pow(x.value, y.value), x.unit);
     },
     percentage: function (n) {
-        return new Dimension(n.value * 100, '%');
+        var result = mathHelper._math(function(num) {
+            return num * 100;
+        }, '%', n);
+
+        return result;
     }
 });

package/lib/less/index.js

@@ -2,7 +2,7 @@ module.exports = function(environment, fileManagers) {
     var SourceMapOutput, SourceMapBuilder, ParseTree, ImportManager, Environment;
 
     var less = {
-        version: [2, 5, 1],
+        version: [2, 6, 1],
         data: require('./data'),
         tree: require('./tree'),
         Environment: (Environment = require("./environment/environment")),

package/lib/less/parser/parser-input.js

@@ -11,6 +11,74 @@ module.exports = function() {
         currentPos,  // index of current chunk, in `input`
         parserInput = {};
 
+    var CHARCODE_SPACE = 32,
+        CHARCODE_TAB = 9,
+        CHARCODE_LF = 10,
+        CHARCODE_CR = 13,
+        CHARCODE_PLUS = 43,
+        CHARCODE_COMMA = 44,
+        CHARCODE_FORWARD_SLASH = 47,
+        CHARCODE_9 = 57;
+
+    function skipWhitespace(length) {
+        var oldi = parserInput.i, oldj = j,
+            curr = parserInput.i - currentPos,
+            endIndex = parserInput.i + current.length - curr,
+            mem = (parserInput.i += length),
+            inp = input,
+            c, nextChar, comment;
+
+        for (; parserInput.i < endIndex; parserInput.i++) {
+            c = inp.charCodeAt(parserInput.i);
+
+            if (parserInput.autoCommentAbsorb && c === CHARCODE_FORWARD_SLASH) {
+                nextChar = inp.charAt(parserInput.i + 1);
+                if (nextChar === '/') {
+                    comment = {index: parserInput.i, isLineComment: true};
+                    var nextNewLine = inp.indexOf("\n", parserInput.i + 2);
+                    if (nextNewLine < 0) {
+                        nextNewLine = endIndex;
+                    }
+                    parserInput.i = nextNewLine;
+                    comment.text = inp.substr(comment.i, parserInput.i - comment.i);
+                    parserInput.commentStore.push(comment);
+                    continue;
+                } else if (nextChar === '*') {
+                    var nextStarSlash = inp.indexOf("*/", parserInput.i + 2);
+                    if (nextStarSlash >= 0) {
+                        comment = {
+                            index: parserInput.i,
+                            text: inp.substr(parserInput.i, nextStarSlash + 2 - parserInput.i),
+                            isLineComment: false
+                        };
+                        parserInput.i += comment.text.length - 1;
+                        parserInput.commentStore.push(comment);
+                        continue;
+                    }
+                }
+                break;
+            }
+
+            if ((c !== CHARCODE_SPACE) && (c !== CHARCODE_LF) && (c !== CHARCODE_TAB) && (c !== CHARCODE_CR)) {
+                break;
+            }
+        }
+
+        current = current.slice(length + parserInput.i - mem + curr);
+        currentPos = parserInput.i;
+
+        if (!current.length) {
+            if (j < chunks.length - 1) {
+                current = chunks[++j];
+                skipWhitespace(0); // skip space at the beginning of a chunk
+                return true; // things changed
+            }
+            parserInput.finished = true;
+        }
+
+        return oldi !== parserInput.i || oldj !== j;
+    }
+
     parserInput.save = function() {
         currentPos = parserInput.i;
         saveStack.push( { current: current, i: parserInput.i, j: j });
@@ -105,78 +173,10 @@ module.exports = function() {
         return null;
     };
 
-    var CHARCODE_SPACE = 32,
-        CHARCODE_TAB = 9,
-        CHARCODE_LF = 10,
-        CHARCODE_CR = 13,
-        CHARCODE_PLUS = 43,
-        CHARCODE_COMMA = 44,
-        CHARCODE_FORWARD_SLASH = 47,
-        CHARCODE_9 = 57;
-
     parserInput.autoCommentAbsorb = true;
     parserInput.commentStore = [];
     parserInput.finished = false;
 
-    var skipWhitespace = function(length) {
-        var oldi = parserInput.i, oldj = j,
-            curr = parserInput.i - currentPos,
-            endIndex = parserInput.i + current.length - curr,
-            mem = (parserInput.i += length),
-            inp = input,
-            c, nextChar, comment;
-
-        for (; parserInput.i < endIndex; parserInput.i++) {
-            c = inp.charCodeAt(parserInput.i);
-
-            if (parserInput.autoCommentAbsorb && c === CHARCODE_FORWARD_SLASH) {
-                nextChar = inp.charAt(parserInput.i + 1);
-                if (nextChar === '/') {
-                    comment = {index: parserInput.i, isLineComment: true};
-                    var nextNewLine = inp.indexOf("\n", parserInput.i + 2);
-                    if (nextNewLine < 0) {
-                        nextNewLine = endIndex;
-                    }
-                    parserInput.i = nextNewLine;
-                    comment.text = inp.substr(comment.i, parserInput.i - comment.i);
-                    parserInput.commentStore.push(comment);
-                    continue;
-                } else if (nextChar === '*') {
-                    var nextStarSlash = inp.indexOf("*/", parserInput.i + 2);
-                    if (nextStarSlash >= 0) {
-                        comment = {
-                            index: parserInput.i,
-                            text: inp.substr(parserInput.i, nextStarSlash + 2 - parserInput.i),
-                            isLineComment: false
-                        };
-                        parserInput.i += comment.text.length - 1;
-                        parserInput.commentStore.push(comment);
-                        continue;
-                    }
-                }
-                break;
-            }
-
-            if ((c !== CHARCODE_SPACE) && (c !== CHARCODE_LF) && (c !== CHARCODE_TAB) && (c !== CHARCODE_CR)) {
-                break;
-            }
-        }
-
-        current = current.slice(length + parserInput.i - mem + curr);
-        currentPos = parserInput.i;
-
-        if (!current.length) {
-            if (j < chunks.length - 1) {
-                current = chunks[++j];
-                skipWhitespace(0); // skip space at the beginning of a chunk
-                return true; // things changed
-            }
-            parserInput.finished = true;
-        }
-
-        return oldi !== parserInput.i || oldj !== j;
-    };
-
     // Same as $(), but don't change the state of the parser,
     // just return the match.
     parserInput.peek = function(tok) {

package/lib/less/parser/parser.js

@@ -35,15 +35,27 @@ var LessError = require('../less-error'),
 //    Token matching is done with the `$` function, which either takes
 //    a terminal string or regexp, or a non-terminal function to call.
 //    It also takes care of moving all the indices forwards.
-//
+//`
 //
 var Parser = function Parser(context, imports, fileInfo) {
     var parsers,
         parserInput = getParserInput();
 
+    function error(msg, type) {
+        throw new LessError(
+            {
+                index: parserInput.i,
+                filename: fileInfo.filename,
+                type: type || 'Syntax',
+                message: msg
+            },
+            imports
+        );
+    }
+
     function expect(arg, msg, index) {
         // some older browsers return typeof 'function' for RegExp
-        var result = (Object.prototype.toString.call(arg) === '[object Function]') ? arg.call(parsers) : parserInput.$re(arg);
+        var result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
         if (result) {
             return result;
         }
@@ -59,18 +71,6 @@ var Parser = function Parser(context, imports, fileInfo) {
         error(msg || "expected '" + arg + "' got '" + parserInput.currentChar() + "'");
     }
 
-    function error(msg, type) {
-        throw new LessError(
-            {
-                index: parserInput.i,
-                filename: fileInfo.filename,
-                type: type || 'Syntax',
-                message: msg
-            },
-            imports
-        );
-    }
-
     function getDebugInfo(index) {
         var filename = fileInfo.filename;
 
@@ -489,7 +489,25 @@ var Parser = function Parser(context, imports, fileInfo) {
                         if (!colorCandidateString.match(/^[A-Fa-f0-9]+$/)) { // verify if candidate consists only of allowed HEX characters
                             error("Invalid HEX color code");
                         }
-                        return new(tree.Color)(rgb[1]);
+                        return new(tree.Color)(rgb[1], undefined, '#' + colorCandidateString);
+                    }
+                },
+
+                colorKeyword: function () {
+                    parserInput.save();
+                    var autoCommentAbsorb = parserInput.autoCommentAbsorb;
+                    parserInput.autoCommentAbsorb = false;
+                    var k = parserInput.$re(/^[A-Za-z]+/);
+                    parserInput.autoCommentAbsorb = autoCommentAbsorb;
+                    if (!k) {
+                        parserInput.forget();
+                        return;
+                    }
+                    parserInput.restore();
+                    var color = tree.Color.fromKeyword(k);
+                    if (color) {
+                        parserInput.$str(k);
+                        return color;
                     }
                 },
 
@@ -503,7 +521,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                         return;
                     }
 
-                    var value = parserInput.$re(/^([+-]?\d*\.?\d+)(%|[a-z]+)?/i);
+                    var value = parserInput.$re(/^([+-]?\d*\.?\d+)(%|[a-z_]+)?/i);
                     if (value) {
                         return new(tree.Dimension)(value[1], value[2]);
                     }
@@ -569,7 +587,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             rulesetCall: function () {
                 var name;
 
-                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*\(\s*\)\s*;/))) {
+                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\(\s*\)\s*;/))) {
                     return new tree.RulesetCall(name[1]);
                 }
             },
@@ -603,7 +621,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (!elements) {
                         error("Missing target selector for :extend().");
                     }
-                    extend = new(tree.Extend)(new(tree.Selector)(elements), option, index);
+                    extend = new(tree.Extend)(new(tree.Selector)(elements), option, index, fileInfo);
                     if (extendList) {
                         extendList.push(extend);
                     } else {
@@ -687,7 +705,8 @@ var Parser = function Parser(context, imports, fileInfo) {
                     var entities = parsers.entities,
                         returner = { args:null, variadic: false },
                         expressions = [], argsSemiColon = [], argsComma = [],
-                        isSemiColonSeparated, expressionContainsNamed, name, nameLoop, value, arg;
+                        isSemiColonSeparated, expressionContainsNamed, name, nameLoop,
+                        value, arg, expand;
 
                     parserInput.save();
 
@@ -749,14 +768,18 @@ var Parser = function Parser(context, imports, fileInfo) {
                                     }
                                 }
                                 nameLoop = (name = val.name);
-                            } else if (!isCall && parserInput.$str("...")) {
-                                returner.variadic = true;
-                                if (parserInput.$char(";") && !isSemiColonSeparated) {
-                                    isSemiColonSeparated = true;
+                            } else if (parserInput.$str("...")) {
+                                if (!isCall) {
+                                    returner.variadic = true;
+                                    if (parserInput.$char(";") && !isSemiColonSeparated) {
+                                        isSemiColonSeparated = true;
+                                    }
+                                    (isSemiColonSeparated ? argsSemiColon : argsComma)
+                                        .push({ name: arg.name, variadic: true });
+                                    break;
+                                } else {
+                                    expand = true;
                                 }
-                                (isSemiColonSeparated ? argsSemiColon : argsComma)
-                                    .push({ name: arg.name, variadic: true });
-                                break;
                             } else if (!isCall) {
                                 name = nameLoop = val.name;
                                 value = null;
@@ -767,7 +790,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                             expressions.push(value);
                         }
 
-                        argsComma.push({ name:nameLoop, value:value });
+                        argsComma.push({ name:nameLoop, value:value, expand:expand });
 
                         if (parserInput.$char(',')) {
                             continue;
@@ -784,7 +807,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                             if (expressions.length > 1) {
                                 value = new(tree.Value)(expressions);
                             }
-                            argsSemiColon.push({ name:name, value:value });
+                            argsSemiColon.push({ name:name, value:value, expand:expand });
 
                             name = null;
                             expressions = [];
@@ -1264,12 +1287,10 @@ var Parser = function Parser(context, imports, fileInfo) {
                             } else if (e) {
                                 nodes.push(new(tree.Paren)(e));
                             } else {
-                                parserInput.restore("badly formed media feature definition");
-                                return null;
+                                error("badly formed media feature definition");
                             }
                         } else {
-                            parserInput.restore("Missing closing ')'");
-                            return null;
+                            error("Missing closing ')'", "Parse");
                         }
                     }
                 } while (e);
@@ -1314,8 +1335,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     rules = this.block();
 
                     if (!rules) {
-                        parserInput.restore("media definitions require block statements after any features");
-                        return;
+                        error("media definitions require block statements after any features");
                     }
 
                     parserInput.forget();
@@ -1393,33 +1413,6 @@ var Parser = function Parser(context, imports, fileInfo) {
                 }
 
                 switch(nonVendorSpecificName) {
-                    /*
-                    case "@font-face":
-                    case "@viewport":
-                    case "@top-left":
-                    case "@top-left-corner":
-                    case "@top-center":
-                    case "@top-right":
-                    case "@top-right-corner":
-                    case "@bottom-left":
-                    case "@bottom-left-corner":
-                    case "@bottom-center":
-                    case "@bottom-right":
-                    case "@bottom-right-corner":
-                    case "@left-top":
-                    case "@left-middle":
-                    case "@left-bottom":
-                    case "@right-top":
-                    case "@right-middle":
-                    case "@right-bottom":
-                        hasBlock = true;
-                        isRooted = true;
-                        break;
-                    */
-                    case "@counter-style":
-                        hasIdentifier = true;
-                        hasBlock = true;
-                        break;
                     case "@charset":
                         hasIdentifier = true;
                         hasBlock = false;
@@ -1429,17 +1422,17 @@ var Parser = function Parser(context, imports, fileInfo) {
                         hasBlock = false;
                         break;
                     case "@keyframes":
+                    case "@counter-style":
                         hasIdentifier = true;
                         break;
-                    case "@host":
-                    case "@page":
-                        hasUnknown = true;
-                        break;
                     case "@document":
                     case "@supports":
                         hasUnknown = true;
                         isRooted = false;
                         break;
+                    default:
+                        hasUnknown = true;
+                        break;
                 }
 
                 parserInput.commentStore.length = 0;
@@ -1456,6 +1449,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     }
                 } else if (hasUnknown) {
                     value = (parserInput.$re(/^[^{;]+/) || '').trim();
+                    hasBlock = (parserInput.currentChar() == '{');
                     if (value) {
                         value = new(tree.Anonymous)(value);
                     }
@@ -1469,7 +1463,6 @@ var Parser = function Parser(context, imports, fileInfo) {
                     parserInput.forget();
                     return new (tree.Directive)(name, value, rules, index, fileInfo,
                         context.dumpLineNumbers ? getDebugInfo(index) : null,
-                        false,
                         isRooted
                     );
                 }
@@ -1593,11 +1586,103 @@ var Parser = function Parser(context, imports, fileInfo) {
                 }
             },
             condition: function () {
-                var entities = this.entities, index = parserInput.i, negate = false,
-                    a, b, c, op;
+                var result, logical, next;
+                function or() {
+                    return parserInput.$str("or");
+                }
+
+                result = this.conditionAnd(this);
+                if (!result) {
+                    return ;
+                }
+                logical = or();
+                if (logical) {
+                    next = this.condition();
+                    if (next) {
+                        result = new(tree.Condition)(logical, result, next);
+                    } else {
+                        return ;
+                    }
+                }
+                return result;
+            },
+            conditionAnd: function () {
+                var result, logical, next;
+                function insideCondition(me) {
+                    return me.negatedCondition() || me.parenthesisCondition();
+                }
+                function and() {
+                    return parserInput.$str("and");
+                }
+
+                result = insideCondition(this);
+                if (!result) {
+                    return ;
+                }
+                logical = and();
+                if (logical) {
+                    next = this.conditionAnd();
+                    if (next) {
+                        result = new(tree.Condition)(logical, result, next);
+                    } else {
+                        return ;
+                    }
+                }
+                return result;
+            },
+            negatedCondition: function () {
+                if (parserInput.$str("not")) {
+                    var result = this.parenthesisCondition();
+                    if (result) {
+                        result.negate = !result.negate;
+                    }
+                    return result;
+                }
+            },
+            parenthesisCondition: function () {
+                function tryConditionFollowedByParenthesis(me) {
+                    var body;
+                    parserInput.save();
+                    body = me.condition();
+                    if (!body) {
+                        parserInput.restore();
+                        return ;
+                    }
+                    if (!parserInput.$char(')')) {
+                        parserInput.restore();
+                        return ;
+                    }
+                    parserInput.forget();
+                    return body;
+                }
+
+                var body;
+                parserInput.save();
+                if (!parserInput.$str("(")) {
+                    parserInput.restore();
+                    return ;
+                }
+                body = tryConditionFollowedByParenthesis(this);
+                if (body) {
+                    parserInput.forget();
+                    return body;
+                }
+
+                body = this.atomicCondition();
+                if (!body) {
+                    parserInput.restore();
+                    return ;
+                }
+                if (!parserInput.$char(')')) {
+                    parserInput.restore("expected ')' got '" + parserInput.currentChar() + "'");
+                    return ;
+                }
+                parserInput.forget();
+                return body;
+            },
+            atomicCondition: function () {
+                var entities = this.entities, index = parserInput.i, a, b, c, op;
 
-                if (parserInput.$str("not")) { negate = true; }
-                expectChar('(');
                 a = this.addition() || entities.keyword() || entities.quoted();
                 if (a) {
                     if (parserInput.$char('>')) {
@@ -1626,15 +1711,14 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (op) {
                         b = this.addition() || entities.keyword() || entities.quoted();
                         if (b) {
-                            c = new(tree.Condition)(op, a, b, index, negate);
+                            c = new(tree.Condition)(op, a, b, index, false);
                         } else {
                             error('expected expression');
                         }
                     } else {
-                        c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, negate);
+                        c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, false);
                     }
-                    expectChar(')');
-                    return parserInput.$str("and") ? new(tree.Condition)('and', c, this.condition()) : c;
+                    return c;
                 }
             },
 
@@ -1651,7 +1735,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                 var o = this.sub() || entities.dimension() ||
                         entities.color() || entities.variable() ||
-                        entities.call();
+                        entities.call() || entities.colorKeyword();
 
                 if (negate) {
                     o.parensInOp = true;

package/lib/less/transform-tree.js

@@ -39,6 +39,7 @@ module.exports = function(root, options) {
     var preEvalVisitors = [],
         visitors = [
             new visitor.JoinSelectorVisitor(),
+            new visitor.MarkVisibleSelectorsVisitor(true),
             new visitor.ExtendVisitor(),
             new visitor.ToCSSVisitor({compress: Boolean(options.compress)})
         ], i;