less 2.4.0 → 2.5.3

package/lib/less/parser/parser.js

@@ -43,7 +43,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
     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.$(arg);
+        var result = (Object.prototype.toString.call(arg) === '[object Function]') ? arg.call(parsers) : parserInput.$re(arg);
         if (result) {
             return result;
         }
@@ -122,7 +122,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             // output. The callback is called when the input is parsed.
             try {
                 parserInput.start(str, context.chunkInput, function fail(msg, index) {
-                    throw LessError({
+                    throw new LessError({
                         index: index,
                         type: 'Parse',
                         message: msg,
@@ -217,7 +217,7 @@ var Parser = function Parser(context, imports, fileInfo) {
         //         Ruleset (Selector [Element '>', '.child'], [...])
         //     ])
         //
-        //  In general, most rules will try to parse a token with the `$()` function, and if the return
+        //  In general, most rules will try to parse a token with the `$re()` function, and if the return
         //  value is truly, will return a new node, of the relevant type. Sometimes, we need to check
         //  first, before parsing, that's when we use `peek()`.
         //
@@ -240,8 +240,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             primary: function () {
                 var mixin = this.mixin, root = [], node;
 
-                while (true)
-                {
+                while (true) {
                     while (true) {
                         node = this.comment();
                         if (!node) { break; }
@@ -266,7 +265,11 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (node) {
                         root.push(node);
                     } else {
-                        if (!(parserInput.$re(/^[\s\n]+/) || parserInput.$re(/^;+/))) {
+                        var foundSemiColon = false;
+                        while (parserInput.$char(";")) {
+                            foundSemiColon = true;
+                        }
+                        if (!foundSemiColon) {
                             break;
                         }
                     }
@@ -294,12 +297,20 @@ var Parser = function Parser(context, imports, fileInfo) {
                 //     "milky way" 'he\'s the one!'
                 //
                 quoted: function () {
-                    var str, index = parserInput.i;
+                    var str, index = parserInput.i, isEscaped = false;
 
-                    str = parserInput.$re(/^(~)?("((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)')/);
-                    if (str) {
-                        return new(tree.Quoted)(str[2], str[3] || str[4], Boolean(str[1]), index, fileInfo);
+                    parserInput.save();
+                    if (parserInput.$char("~")) {
+                        isEscaped = true;
+                    }
+                    str = parserInput.$quoted();
+                    if (!str) {
+                        parserInput.restore();
+                        return;
                     }
+                    parserInput.forget();
+
+                    return new(tree.Quoted)(str.charAt(0), str.substr(1, str.length - 2), isEscaped, index, fileInfo);
                 },
 
                 //
@@ -308,7 +319,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 //     black border-collapse
                 //
                 keyword: function () {
-                    var k = parserInput.$re(/^%|^[_A-Za-z-][_A-Za-z0-9-]*/);
+                    var k = parserInput.$char("%") || parserInput.$re(/^[_A-Za-z-][_A-Za-z0-9-]*/);
                     if (k) {
                         return tree.Color.fromKeyword(k) || new(tree.Keyword)(k);
                     }
@@ -327,6 +338,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 call: function () {
                     var name, nameLC, args, alpha, index = parserInput.i;
 
+                    // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
                     if (parserInput.peek(/^url\(/i)) {
                         return;
                     }
@@ -342,6 +354,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (nameLC === 'alpha') {
                         alpha = parsers.alpha();
                         if (alpha) {
+                            parserInput.forget();
                             return alpha;
                         }
                     }
@@ -386,16 +399,22 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                 assignment: function () {
                     var key, value;
+                    parserInput.save();
                     key = parserInput.$re(/^\w+(?=\s?=)/i);
                     if (!key) {
+                        parserInput.restore();
                         return;
                     }
                     if (!parserInput.$char('=')) {
+                        parserInput.restore();
                         return;
                     }
                     value = parsers.entity();
                     if (value) {
+                        parserInput.forget();
                         return new(tree.Assignment)(key, value);
+                    } else {
+                        parserInput.restore();
                     }
                 },
 
@@ -411,7 +430,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                     parserInput.autoCommentAbsorb = false;
 
-                    if (parserInput.currentChar() !== 'u' || !parserInput.$re(/^url\(/)) {
+                    if (!parserInput.$str("url(")) {
                         parserInput.autoCommentAbsorb = true;
                         return;
                     }
@@ -470,7 +489,7 @@ 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);
                     }
                 },
 
@@ -512,10 +531,22 @@ var Parser = function Parser(context, imports, fileInfo) {
                 javascript: function () {
                     var js, index = parserInput.i;
 
-                    js = parserInput.$re(/^(~)?`([^`]*)`/);
+                    parserInput.save();
+
+                    var escape = parserInput.$char("~");
+                    var jsQuote = parserInput.$char("`");
+
+                    if (!jsQuote) {
+                        parserInput.restore();
+                        return;
+                    }
+
+                    js = parserInput.$re(/^[^`]*`/);
                     if (js) {
-                        return new(tree.JavaScript)(js[2], Boolean(js[1]), index, fileInfo);
+                        parserInput.forget();
+                        return new(tree.JavaScript)(js.substr(0, js.length - 1), Boolean(escape), index, fileInfo);
                     }
+                    parserInput.restore("invalid javascript definition");
                 }
             },
 
@@ -549,7 +580,9 @@ var Parser = function Parser(context, imports, fileInfo) {
             extend: function(isRule) {
                 var elements, e, index = parserInput.i, option, extendList, extend;
 
-                if (!(isRule ? parserInput.$re(/^&:extend\(/) : parserInput.$re(/^:extend\(/))) { return; }
+                if (!parserInput.$str(isRule ? "&:extend(" : ":extend(")) {
+                    return;
+                }
 
                 do {
                     option = null;
@@ -654,7 +687,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();
 
@@ -663,7 +697,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                             arg = parsers.detachedRuleset() || parsers.expression();
                         } else {
                             parserInput.commentStore.length = 0;
-                            if (parserInput.currentChar() === '.' && parserInput.$re(/^\.{3}/)) {
+                            if (parserInput.$str("...")) {
                                 returner.variadic = true;
                                 if (parserInput.$char(";") && !isSemiColonSeparated) {
                                     isSemiColonSeparated = true;
@@ -704,10 +738,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                                     expressionContainsNamed = true;
                                 }
 
-                                // we do not support setting a ruleset as a default variable - it doesn't make sense
-                                // However if we do want to add it, there is nothing blocking it, just don't error
-                                // and remove isCall dependency below
-                                value = (isCall && parsers.detachedRuleset()) || parsers.expression();
+                                value = parsers.detachedRuleset() || parsers.expression();
 
                                 if (!value) {
                                     if (isCall) {
@@ -719,14 +750,18 @@ var Parser = function Parser(context, imports, fileInfo) {
                                     }
                                 }
                                 nameLoop = (name = val.name);
-                            } else if (!isCall && parserInput.$re(/^\.{3}/)) {
-                                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;
@@ -737,7 +772,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;
@@ -754,7 +789,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 = [];
@@ -814,7 +849,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                         parserInput.commentStore.length = 0;
 
-                        if (parserInput.$re(/^when/)) { // Guard
+                        if (parserInput.$str("when")) { // Guard
                             cond = expect(parsers.conditions, 'expected condition');
                         }
 
@@ -860,6 +895,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             alpha: function () {
                 var value;
 
+                // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
                 if (! parserInput.$re(/^opacity=/i)) { return; }
                 value = parserInput.$re(/^\d+/);
                 if (!value) {
@@ -963,7 +999,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             selector: function (isLess) {
                 var index = parserInput.i, elements, extendList, c, e, allExtends, when, condition;
 
-                while ((isLess && (extendList = this.extend())) || (isLess && (when = parserInput.$re(/^when/))) || (e = this.element())) {
+                while ((isLess && (extendList = this.extend())) || (isLess && (when = parserInput.$str("when"))) || (e = this.element())) {
                     if (when) {
                         condition = expect(this.conditions, 'expected condition');
                     } else if (condition) {
@@ -1086,7 +1122,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             rule: function (tryAnonymous) {
                 var name, value, startOfRule = parserInput.i, c = parserInput.currentChar(), important, merge, isVariable;
 
-                if (c === '.' || c === '#' || c === '&') { return; }
+                if (c === '.' || c === '#' || c === '&' || c === ':') { return; }
 
                 parserInput.save();
 
@@ -1103,7 +1139,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                         // a name returned by this.ruleProperty() is always an array of the form:
                         // [string-1, ..., string-n, ""] or [string-1, ..., string-n, "+"]
                         // where each item is a tree.Keyword or tree.Variable
-                        merge = !isVariable && name.pop().value;
+                        merge = !isVariable && name.length > 1 && name.pop().value;
 
                         // prefer to try to parse first if its a variable or we are compressing
                         // but always fallback on the other one
@@ -1116,7 +1152,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                             value = this.anonymousValue();
                             if (value) {
                                 parserInput.forget();
-                                // anonymous values absorb the end ';' which is reequired for them to work
+                                // anonymous values absorb the end ';' which is required for them to work
                                 return new (tree.Rule)(name, value, false, merge, startOfRule, fileInfo);
                             }
                         }
@@ -1168,15 +1204,14 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if ((path = this.entities.quoted() || this.entities.url())) {
                         features = this.mediaFeatures();
 
-                        if (!parserInput.$(';')) {
+                        if (!parserInput.$char(';')) {
                             parserInput.i = index;
                             error("missing semi-colon or unrecognised media features on import");
                         }
                         features = features && new(tree.Value)(features);
                         return new(tree.Import)(path, features, options, index, fileInfo);
                     }
-                    else
-                    {
+                    else {
                         parserInput.i = index;
                         error("malformed import statement");
                     }
@@ -1276,16 +1311,61 @@ var Parser = function Parser(context, imports, fileInfo) {
                     debugInfo = getDebugInfo(parserInput.i);
                 }
 
-                if (parserInput.$re(/^@media/)) {
+                parserInput.save();
+
+                if (parserInput.$str("@media")) {
                     features = this.mediaFeatures();
 
                     rules = this.block();
-                    if (rules) {
-                        media = new(tree.Media)(rules, features, parserInput.i, fileInfo);
-                        if (context.dumpLineNumbers) {
-                            media.debugInfo = debugInfo;
+
+                    if (!rules) {
+                        parserInput.restore("media definitions require block statements after any features");
+                        return;
+                    }
+
+                    parserInput.forget();
+
+                    media = new(tree.Media)(rules, features, parserInput.i, fileInfo);
+                    if (context.dumpLineNumbers) {
+                        media.debugInfo = debugInfo;
+                    }
+
+                    return media;
+                }
+
+                parserInput.restore();
+            },
+
+            //
+            // A @plugin directive, used to import compiler extensions dynamically.
+            //
+            //     @plugin "lib";
+            //
+            // Depending on our environment, importing is done differently:
+            // In the browser, it's an XHR request, in Node, it would be a
+            // file-system operation. The function used for importing is
+            // stored in `import`, which we pass to the Import constructor.
+            //
+            plugin: function () {
+                var path,
+                    index = parserInput.i,
+                    dir   = parserInput.$re(/^@plugin?\s+/);
+
+                if (dir) {
+                    var options = { plugin : true };
+
+                    if ((path = this.entities.quoted() || this.entities.url())) {
+
+                        if (!parserInput.$char(';')) {
+                            parserInput.i = index;
+                            error("missing semi-colon on plugin");
                         }
-                        return media;
+
+                        return new(tree.Import)(path, null, options, index, fileInfo);
+                    }
+                    else {
+                        parserInput.i = index;
+                        error("malformed plugin statement");
                     }
                 }
             },
@@ -1297,11 +1377,11 @@ var Parser = function Parser(context, imports, fileInfo) {
             //
             directive: function () {
                 var index = parserInput.i, name, value, rules, nonVendorSpecificName,
-                    hasIdentifier, hasExpression, hasUnknown, hasBlock = true;
+                    hasIdentifier, hasExpression, hasUnknown, hasBlock = true, isRooted = true;
 
                 if (parserInput.currentChar() !== '@') { return; }
 
-                value = this['import']() || this.media();
+                value = this['import']() || this.plugin() || this.media();
                 if (value) {
                     return value;
                 }
@@ -1338,6 +1418,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     case "@right-middle":
                     case "@right-bottom":
                         hasBlock = true;
+                        isRooted = true;
                         break;
                     */
                     case "@counter-style":
@@ -1357,9 +1438,12 @@ var Parser = function Parser(context, imports, fileInfo) {
                         break;
                     case "@host":
                     case "@page":
+                        hasUnknown = true;
+                        break;
                     case "@document":
                     case "@supports":
                         hasUnknown = true;
+                        isRooted = false;
                         break;
                 }
 
@@ -1388,8 +1472,11 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                 if (rules || (!hasBlock && value && parserInput.$char(';'))) {
                     parserInput.forget();
-                    return new(tree.Directive)(name, value, rules, index, fileInfo,
-                        context.dumpLineNumbers ? getDebugInfo(index) : null);
+                    return new (tree.Directive)(name, value, rules, index, fileInfo,
+                        context.dumpLineNumbers ? getDebugInfo(index) : null,
+                        false,
+                        isRooted
+                    );
                 }
 
                 parserInput.restore("directive options not recognised");
@@ -1514,11 +1601,33 @@ var Parser = function Parser(context, imports, fileInfo) {
                 var entities = this.entities, index = parserInput.i, negate = false,
                     a, b, c, op;
 
-                if (parserInput.$re(/^not/)) { negate = true; }
+                if (parserInput.$str("not")) { negate = true; }
                 expectChar('(');
                 a = this.addition() || entities.keyword() || entities.quoted();
                 if (a) {
-                    op = parserInput.$re(/^(?:>=|<=|=<|[<=>])/);
+                    if (parserInput.$char('>')) {
+                        if (parserInput.$char('=')) {
+                            op = ">=";
+                        } else {
+                            op = '>';
+                        }
+                    } else
+                    if (parserInput.$char('<')) {
+                        if (parserInput.$char('=')) {
+                            op = "<=";
+                        } else {
+                            op = '<';
+                        }
+                    } else
+                    if (parserInput.$char('=')) {
+                        if (parserInput.$char('>')) {
+                            op = "=>";
+                        } else if (parserInput.$char('<')) {
+                            op = '=<';
+                        } else {
+                            op = '=';
+                        }
+                    }
                     if (op) {
                         b = this.addition() || entities.keyword() || entities.quoted();
                         if (b) {
@@ -1530,7 +1639,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                         c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, negate);
                     }
                     expectChar(')');
-                    return parserInput.$re(/^and/) ? new(tree.Condition)('and', c, this.condition()) : c;
+                    return parserInput.$str("and") ? new(tree.Condition)('and', c, this.condition()) : c;
                 }
             },
 
@@ -1600,6 +1709,13 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                 parserInput.save();
 
+                var simpleProperty = parserInput.$re(/^([_a-zA-Z0-9-]+)\s*:/);
+                if (simpleProperty) {
+                    name = [new(tree.Keyword)(simpleProperty[1])];
+                    parserInput.forget();
+                    return name;
+                }
+
                 function match(re) {
                     var i = parserInput.i,
                         chunk = parserInput.$re(re);

package/lib/less/plugins/function-importer.js

@@ -0,0 +1,35 @@
+var LessError = require('../less-error'),
+    tree = require("../tree");
+
+var FunctionImporter = module.exports = function FunctionImporter(context, fileInfo) {
+    this.fileInfo = fileInfo;
+};
+
+FunctionImporter.prototype.eval = function(contents, callback) {
+    var loaded = {},
+        loader,
+        registry;
+
+    registry = {
+        add: function(name, func) {
+            loaded[name] = func;
+        },
+        addMultiple: function(functions) {
+            Object.keys(functions).forEach(function(name) {
+                loaded[name] = functions[name];
+            });
+        }
+    };
+
+    try {
+        loader = new Function("functions", "tree", "fileInfo", contents);
+        loader(registry, tree, this.fileInfo);
+    } catch(e) {
+        callback(new LessError({
+            message: "Plugin evaluation error: '" + e.name + ': ' + e.message.replace(/["]/g, "'") + "'" ,
+            filename: this.fileInfo.filename
+        }), null );
+    }
+
+    callback(null, { functions: loaded });
+};

package/lib/less/source-map-output.js

@@ -105,8 +105,7 @@ module.exports = function (environment) {
 
         if (this._outputSourceFiles) {
             for (var filename in this._contentsMap) {
-                if (this._contentsMap.hasOwnProperty(filename))
-                {
+                if (this._contentsMap.hasOwnProperty(filename)) {
                     var source = this._contentsMap[filename];
                     if (this._contentsIgnoredCharsMap[filename]) {
                         source = source.slice(this._contentsIgnoredCharsMap[filename]);

package/lib/less/tree/anonymous.js

@@ -1,16 +1,17 @@
 var Node = require("./node");
 
-var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike) {
+var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike, referenced) {
     this.value = value;
     this.index = index;
     this.mapLines = mapLines;
     this.currentFileInfo = currentFileInfo;
     this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
+    this.isReferenced = referenced || false;
 };
 Anonymous.prototype = new Node();
 Anonymous.prototype.type = "Anonymous";
 Anonymous.prototype.eval = function () {
-    return new Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines, this.rulesetLike);
+    return new Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines, this.rulesetLike, this.isReferenced);
 };
 Anonymous.prototype.compare = function (other) {
     return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
@@ -21,4 +22,11 @@ Anonymous.prototype.isRulesetLike = function() {
 Anonymous.prototype.genCSS = function (context, output) {
     output.add(this.value, this.currentFileInfo, this.index, this.mapLines);
 };
+Anonymous.prototype.markReferenced = function () {
+    this.isReferenced = true;
+};
+Anonymous.prototype.getIsReferenced = function () {
+    return !this.currentFileInfo || !this.currentFileInfo.reference || this.isReferenced;
+};
+
 module.exports = Anonymous;

package/lib/less/tree/color.js

@@ -4,7 +4,7 @@ var Node = require("./node"),
 //
 // RGB Colors - #ff0014, #eee
 //
-var Color = function (rgb, a) {
+var Color = function (rgb, a, originalForm) {
     //
     // The end goal here, is to parse the arguments
     // into an integer triplet, such as `128, 255, 0`
@@ -23,6 +23,9 @@ var Color = function (rgb, a) {
         });
     }
     this.alpha = typeof a === 'number' ? a : 1;
+    if (typeof originalForm !== 'undefined') {
+        this.value = originalForm;
+    }
 };
 
 Color.prototype = new Node();

package/lib/less/tree/comment.js

@@ -22,7 +22,4 @@ Comment.prototype.isSilent = function(context) {
 Comment.prototype.markReferenced = function () {
     this.isReferenced = true;
 };
-Comment.prototype.isRulesetLike = function(root) {
-    return Boolean(root);
-};
 module.exports = Comment;

package/lib/less/tree/dimension.js

@@ -63,8 +63,10 @@ Dimension.prototype.operate = function (context, op, other) {
 
     if (op === '+' || op === '-') {
         if (unit.numerator.length === 0 && unit.denominator.length === 0) {
-            unit.numerator = other.unit.numerator.slice(0);
-            unit.denominator = other.unit.denominator.slice(0);
+            unit = other.unit.clone();
+            if (this.unit.backupUnit) {
+                unit.backupUnit = this.unit.backupUnit;
+            }
         } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
             // do nothing
         } else {
@@ -125,7 +127,7 @@ Dimension.prototype.convertTo = function (conversions) {
         conversions = derivedConversions;
     }
     applyUnit = function (atomicUnit, denominator) {
-      /*jshint loopfunc:true */
+        /* jshint loopfunc:true */
         if (group.hasOwnProperty(atomicUnit)) {
             if (denominator) {
                 value = value / (group[atomicUnit] / group[targetUnit]);