less 2.4.0 → 2.5.3

package/lib/less/contexts.js

@@ -57,6 +57,8 @@ var evalCopyProperties = [
 contexts.Eval = function(options, frames) {
     copyFromOriginal(options, this, evalCopyProperties);
 
+    if (typeof this.paths === "string") { this.paths = [this.paths]; }
+
     this.frames = frames || [];
     this.importantScope = this.importantScope || [];
 };

package/lib/less/environment/abstract-file-manager.js

@@ -16,8 +16,12 @@ abstractFileManager.prototype.getPath = function (filename) {
     return filename.slice(0, j + 1);
 };
 
+abstractFileManager.prototype.tryAppendExtension = function(path, ext) {
+    return /(\.[a-z]*$)|([\?;].*)$/.test(path) ? path : path + ext;
+};
+
 abstractFileManager.prototype.tryAppendLessExtension = function(path) {
-    return /(\.[a-z]*$)|([\?;].*)$/.test(path) ? path : path + '.less';
+    return this.tryAppendExtension(path, '.less');
 };
 
 abstractFileManager.prototype.supportsSync = function() {

package/lib/less/functions/color.js

@@ -141,7 +141,7 @@ colorFunctions = {
 
         return new Dimension(luminance * color.alpha * 100, '%');
     },
-    saturate: function (color, amount) {
+    saturate: function (color, amount, method) {
         // filter: saturate(3.2);
         // should be kept as is, so check for color
         if (!color.rgb) {
@@ -149,42 +149,72 @@ colorFunctions = {
         }
         var hsl = color.toHSL();
 
-        hsl.s += amount.value / 100;
+        if (typeof method !== "undefined" && method.value === "relative") {
+            hsl.s +=  hsl.s * amount.value / 100;
+        }
+        else {
+            hsl.s += amount.value / 100;
+        }
         hsl.s = clamp(hsl.s);
         return hsla(hsl);
     },
-    desaturate: function (color, amount) {
+    desaturate: function (color, amount, method) {
         var hsl = color.toHSL();
 
-        hsl.s -= amount.value / 100;
+        if (typeof method !== "undefined" && method.value === "relative") {
+            hsl.s -=  hsl.s * amount.value / 100;
+        }
+        else {
+            hsl.s -= amount.value / 100;
+        }
         hsl.s = clamp(hsl.s);
         return hsla(hsl);
     },
-    lighten: function (color, amount) {
+    lighten: function (color, amount, method) {
         var hsl = color.toHSL();
 
-        hsl.l += amount.value / 100;
+        if (typeof method !== "undefined" && method.value === "relative") {
+            hsl.l +=  hsl.l * amount.value / 100;
+        }
+        else {
+            hsl.l += amount.value / 100;
+        }
         hsl.l = clamp(hsl.l);
         return hsla(hsl);
     },
-    darken: function (color, amount) {
+    darken: function (color, amount, method) {
         var hsl = color.toHSL();
 
-        hsl.l -= amount.value / 100;
+        if (typeof method !== "undefined" && method.value === "relative") {
+            hsl.l -=  hsl.l * amount.value / 100;
+        }
+        else {
+            hsl.l -= amount.value / 100;
+        }
         hsl.l = clamp(hsl.l);
         return hsla(hsl);
     },
-    fadein: function (color, amount) {
+    fadein: function (color, amount, method) {
         var hsl = color.toHSL();
 
-        hsl.a += amount.value / 100;
+        if (typeof method !== "undefined" && method.value === "relative") {
+            hsl.a +=  hsl.a * amount.value / 100;
+        }
+        else {
+            hsl.a += amount.value / 100;
+        }
         hsl.a = clamp(hsl.a);
         return hsla(hsl);
     },
-    fadeout: function (color, amount) {
+    fadeout: function (color, amount, method) {
         var hsl = color.toHSL();
 
-        hsl.a -= amount.value / 100;
+        if (typeof method !== "undefined" && method.value === "relative") {
+            hsl.a -=  hsl.a * amount.value / 100;
+        }
+        else {
+            hsl.a -= amount.value / 100;
+        }
         hsl.a = clamp(hsl.a);
         return hsla(hsl);
     },
@@ -208,6 +238,10 @@ colorFunctions = {
     // http://sass-lang.com
     //
     mix: function (color1, color2, weight) {
+        if (!color1.toHSL || !color2.toHSL) {
+            console.log(color2.type);
+            console.dir(color2);
+        }
         if (!weight) {
             weight = new Dimension(50);
         }

package/lib/less/functions/function-caller.js

@@ -1,16 +1,45 @@
-var functionRegistry = require("./function-registry");
+var Expression = require("../tree/expression");
 
 var functionCaller = function(name, context, index, currentFileInfo) {
     this.name = name.toLowerCase();
-    this.func = functionRegistry.get(this.name);
     this.index = index;
     this.context = context;
     this.currentFileInfo = currentFileInfo;
+
+    this.func = context.frames[0].functionRegistry.get(this.name);
 };
 functionCaller.prototype.isValid = function() {
     return Boolean(this.func);
 };
 functionCaller.prototype.call = function(args) {
+
+    // This code is terrible and should be replaced as per this issue...
+    // https://github.com/less/less.js/issues/2477
+    if (Array.isArray(args)) {
+        args = args.filter(function (item) {
+            if (item.type === "Comment") {
+                return false;
+            }
+            return true;
+        })
+        .map(function(item) {
+            if (item.type === "Expression") {
+                var subNodes = item.value.filter(function (item) {
+                    if (item.type === "Comment") {
+                        return false;
+                    }
+                    return true;
+                });
+                if (subNodes.length === 1) {
+                    return subNodes[0];
+                } else {
+                    return new Expression(subNodes);
+                }
+            }
+            return item;
+        });
+    }
+
     return this.func.apply(this, args);
 };
 

package/lib/less/functions/function-registry.js

@@ -1,18 +1,29 @@
-module.exports = {
-    _data: {},
-    add: function(name, func) {
-        if (this._data.hasOwnProperty(name)) {
-            //TODO warn
+function makeRegistry( base ) {
+    return {
+        _data: {},
+        add: function(name, func) {
+            // precautionary case conversion, as later querying of
+            // the registry by function-caller uses lower case as well.
+            name = name.toLowerCase();
+
+            if (this._data.hasOwnProperty(name)) {
+                //TODO warn
+            }
+            this._data[name] = func;
+        },
+        addMultiple: function(functions) {
+            Object.keys(functions).forEach(
+                function(name) {
+                    this.add(name, functions[name]);
+                }.bind(this));
+        },
+        get: function(name) {
+            return this._data[name] || ( base && base.get( name ));
+        },
+        inherit : function() {
+            return makeRegistry( this );
         }
-        this._data[name] = func;
-    },
-    addMultiple: function(functions) {
-        Object.keys(functions).forEach(
-            function(name) {
-                this.add(name, functions[name]);
-            }.bind(this));
-    },
-    get: function(name) {
-        return this._data[name];
-    }
-};
+    };
+}
+
+module.exports = makeRegistry( null );

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/functions/string.js

@@ -14,8 +14,9 @@ functionRegistry.addMultiple({
     },
     replace: function (string, pattern, replacement, flags) {
         var result = string.value;
-
-        result = result.replace(new RegExp(pattern.value, flags ? flags.value : ''), replacement.value);
+        replacement = (replacement.type === "Quoted") ?
+            replacement.value : replacement.toCSS();
+        result = result.replace(new RegExp(pattern.value, flags ? flags.value : ''), replacement);
         return new Quoted(string.quote || '', result, string.escaped);
     },
     '%': function (string /* arg, arg, ...*/) {
@@ -25,7 +26,8 @@ functionRegistry.addMultiple({
         for (var i = 0; i < args.length; i++) {
             /*jshint loopfunc:true */
             result = result.replace(/%[sda]/i, function(token) {
-                var value = token.match(/s/i) ? args[i].value : args[i].toCSS();
+                var value = ((args[i].type === "Quoted") &&
+                    token.match(/s/i)) ? args[i].value : args[i].toCSS();
                 return token.match(/[A-Z]$/) ? encodeURIComponent(value) : value;
             });
         }

package/lib/less/functions/svg.js

@@ -8,23 +8,31 @@ module.exports = function(environment) {
 
     functionRegistry.add("svg-gradient", function(direction) {
 
-        function throwArgumentDescriptor() {
-            throw { type: "Argument",
-                message: "svg-gradient expects direction, start_color [start_position], [color position,]...," +
-                    " end_color [end_position]" };
-        }
-
-        if (arguments.length < 3) {
-            throwArgumentDescriptor();
-        }
-        var stops = Array.prototype.slice.call(arguments, 1),
+        var stops,
             gradientDirectionSvg,
             gradientType = "linear",
             rectangleDimension = 'x="0" y="0" width="1" height="1"',
             renderEnv = {compress: false},
             returner,
             directionValue = direction.toCSS(renderEnv),
-            i, color, position, positionValue, alpha;
+			i, color, position, positionValue, alpha;
+
+        function throwArgumentDescriptor() {
+            throw { type: "Argument",
+					message: "svg-gradient expects direction, start_color [start_position], [color position,]...," +
+							" end_color [end_position] or direction, color list" };
+        }
+
+        if (arguments.length == 2) {
+            if (arguments[1].value.length < 2) {
+                throwArgumentDescriptor();
+            }
+            stops = arguments[1].value;
+        } else if (arguments.length < 3) {
+            throwArgumentDescriptor();
+        } else {
+            stops = Array.prototype.slice.call(arguments, 1);
+        }
 
         switch (directionValue) {
             case "to bottom":

package/lib/less/functions/types.js

@@ -27,12 +27,7 @@ var isa = function (n, Type) {
         var items = Array.isArray(node.value) ?
             node.value : Array(node);
 
-        return items.filter(function(item) {
-            if (item.type === "Comment") {
-                return false;
-            }
-            return true;
-        });
+        return items;
     };
 functionRegistry.addMultiple({
     isruleset: function (n) {

package/lib/less/import-manager.js

@@ -1,5 +1,6 @@
 var contexts = require("./contexts"),
-    Parser = require('./parser/parser');
+    Parser = require('./parser/parser'),
+    FunctionImporter = require('./plugins/function-importer');
 
 module.exports = function(environment) {
 
@@ -65,7 +66,7 @@ module.exports = function(environment) {
         }
 
         if (tryAppendLessExtension) {
-            path = fileManager.tryAppendLessExtension(path);
+            path = fileManager.tryAppendExtension(path, importOptions.plugin ? ".js" : ".less");
         }
 
         var loadFileCallback = function(loadedFile) {
@@ -101,7 +102,11 @@ module.exports = function(environment) {
                 newFileInfo.reference = true;
             }
 
-            if (importOptions.inline) {
+            if (importOptions.plugin) {
+                new FunctionImporter(newEnv, newFileInfo).eval(contents, function (e, root) {
+                    fileParsedFunc(e, root, resolvedFilename);
+                });
+            } else if (importOptions.inline) {
                 fileParsedFunc(null, contents, resolvedFilename);
             } else {
                 new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {

package/lib/less/index.js

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

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

@@ -29,56 +29,11 @@ module.exports = function() {
     parserInput.forget = function() {
         saveStack.pop();
     };
-    function sync() {
-        if (parserInput.i > currentPos) {
-            current = current.slice(parserInput.i - currentPos);
-            currentPos = parserInput.i;
-        }
-    }
     parserInput.isWhitespace = function (offset) {
         var pos = parserInput.i + (offset || 0),
             code = input.charCodeAt(pos);
         return (code === CHARCODE_SPACE || code === CHARCODE_CR || code === CHARCODE_TAB || code === CHARCODE_LF);
     };
-    //
-    // Parse from a token, regexp or string, and move forward if match
-    //
-    parserInput.$ = function(tok) {
-        var tokType = typeof tok,
-            match, length;
-
-        // Either match a single character in the input,
-        // or match a regexp in the current chunk (`current`).
-        //
-        if (tokType === "string") {
-            if (input.charAt(parserInput.i) !== tok) {
-                return null;
-            }
-            skipWhitespace(1);
-            return tok;
-        }
-
-        // regexp
-        sync();
-        if (! (match = tok.exec(current))) {
-            return null;
-        }
-
-        length = match[0].length;
-
-        // The match is confirmed, add the match length to `i`,
-        // and consume any extra white-space characters (' ' || '\n')
-        // which come after that. The reason for this is that LeSS's
-        // grammar is mostly white-space insensitive.
-        //
-        skipWhitespace(length);
-
-        if (typeof match === 'string') {
-            return match;
-        } else {
-            return match.length === 1 ? match[0] : match;
-        }
-    };
 
     // Specialization of $(tok)
     parserInput.$re = function(tok) {
@@ -86,6 +41,7 @@ module.exports = function() {
             current = current.slice(parserInput.i - currentPos);
             currentPos = parserInput.i;
         }
+
         var m = tok.exec(current);
         if (!m) {
             return null;
@@ -99,7 +55,6 @@ module.exports = function() {
         return m.length === 1 ? m[0] : m;
     };
 
-    // Specialization of $(tok)
     parserInput.$char = function(tok) {
         if (input.charAt(parserInput.i) !== tok) {
             return null;
@@ -108,6 +63,48 @@ module.exports = function() {
         return tok;
     };
 
+    parserInput.$str = function(tok) {
+        var tokLength = tok.length;
+
+        // https://jsperf.com/string-startswith/21
+        for (var i = 0; i < tokLength; i++) {
+            if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
+                return null;
+            }
+        }
+
+        skipWhitespace(tokLength);
+        return tok;
+    };
+
+    parserInput.$quoted = function() {
+
+        var startChar = input.charAt(parserInput.i);
+        if (startChar !== "'" && startChar !== '"') {
+            return;
+        }
+        var length = input.length,
+            currentPosition = parserInput.i;
+
+        for (var i = 1; i + currentPosition < length; i++) {
+            var nextChar = input.charAt(i + currentPosition);
+            switch(nextChar) {
+                case "\\":
+                    i++;
+                    continue;
+                case "\r":
+                case "\n":
+                    break;
+                case startChar:
+                    var str = input.substr(currentPosition, i + 1);
+                    skipWhitespace(i + 1);
+                    return str;
+                default:
+            }
+        }
+        return null;
+    };
+
     var CHARCODE_SPACE = 32,
         CHARCODE_TAB = 9,
         CHARCODE_LF = 10,
@@ -136,7 +133,7 @@ module.exports = function() {
                 nextChar = inp.charAt(parserInput.i + 1);
                 if (nextChar === '/') {
                     comment = {index: parserInput.i, isLineComment: true};
-                    var nextNewLine = inp.indexOf("\n", parserInput.i + 1);
+                    var nextNewLine = inp.indexOf("\n", parserInput.i + 2);
                     if (nextNewLine < 0) {
                         nextNewLine = endIndex;
                     }
@@ -145,12 +142,11 @@ module.exports = function() {
                     parserInput.commentStore.push(comment);
                     continue;
                 } else if (nextChar === '*') {
-                    var haystack = inp.substr(parserInput.i);
-                    var comment_search_result = haystack.match(/^\/\*(?:[^*]|\*+[^\/*])*\*+\//);
-                    if (comment_search_result) {
+                    var nextStarSlash = inp.indexOf("*/", parserInput.i + 2);
+                    if (nextStarSlash >= 0) {
                         comment = {
                             index: parserInput.i,
-                            text: comment_search_result[0],
+                            text: inp.substr(parserInput.i, nextStarSlash + 2 - parserInput.i),
                             isLineComment: false
                         };
                         parserInput.i += comment.text.length - 1;
@@ -170,8 +166,7 @@ module.exports = function() {
         currentPos = parserInput.i;
 
         if (!current.length) {
-            if (j < chunks.length - 1)
-            {
+            if (j < chunks.length - 1) {
                 current = chunks[++j];
                 skipWhitespace(0); // skip space at the beginning of a chunk
                 return true; // things changed
@@ -186,7 +181,13 @@ module.exports = function() {
     // just return the match.
     parserInput.peek = function(tok) {
         if (typeof tok === 'string') {
-            return input.charAt(parserInput.i) === tok;
+            // https://jsperf.com/string-startswith/21
+            for (var i = 0; i < tok.length; i++) {
+                if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
+                    return false;
+                }
+            }
+            return true;
         } else {
             return tok.test(current);
         }