less 3.6.0 → 3.8.1

package/lib/less/constants.js

@@ -0,0 +1,13 @@
+module.exports = {
+    Math: {
+        ALWAYS: 0,
+        PARENS_DIVISION: 1,
+        PARENS: 2,
+        STRICT_LEGACY: 3
+    },
+    RewriteUrls: {
+        OFF: 0,
+        LOCAL: 1,
+        ALL: 2
+    }
+};

package/lib/less/contexts.js

@@ -1,5 +1,6 @@
 var contexts = {};
 module.exports = contexts;
+var Constants = require('./constants');
 
 var copyFromOriginal = function copyFromOriginal(original, destination, propertiesToCopy) {
     if (!original) { return; }
@@ -17,7 +18,7 @@ var copyFromOriginal = function copyFromOriginal(original, destination, properti
 var parseCopyProperties = [
     // options
     'paths',            // option - unmodified - paths to search for imports on
-    'relativeUrls',     // option - whether to adjust URL's to be relative
+    'rewriteUrls',      // option - whether to adjust URL's to be relative
     'rootpath',         // option - rootpath to append to URL's
     'strictImports',    // option -
     'insecure',         // option - whether to allow imports from insecure ssl hosts
@@ -43,14 +44,15 @@ var evalCopyProperties = [
     'paths',             // additional include paths
     'compress',          // whether to compress
     'ieCompat',          // whether to enforce IE compatibility (IE8 data-uri)
-    'strictMath',        // whether math has to be within parenthesis
+    'math',              // whether math has to be within parenthesis
     'strictUnits',       // whether units need to evaluate correctly
     'sourceMap',         // whether to output a source map
     'importMultiple',    // whether we are currently importing multiple copies
     'urlArgs',           // whether to add args into url tokens
     'javascriptEnabled', // option - whether Inline JavaScript is enabled. if undefined, defaults to false
     'pluginManager',     // Used as the plugin manager for the session
-    'importantScope'     // used to bubble up !important statements
+    'importantScope',    // used to bubble up !important statements
+    'rewriteUrls'        // option - whether to adjust URL's to be relative
 ];
 
 contexts.Eval = function(options, frames) {
@@ -90,24 +92,49 @@ contexts.Eval.prototype.outOfParenthesis = function () {
 
 contexts.Eval.prototype.inCalc = false;
 contexts.Eval.prototype.mathOn = true;
-contexts.Eval.prototype.isMathOn = function () {
+contexts.Eval.prototype.isMathOn = function (op) {
     if (!this.mathOn) {
         return false;
     }
-    return this.strictMath ? (this.parensStack && this.parensStack.length) : true;
+    if (op === '/' && this.math !== Constants.Math.ALWAYS && (!this.parensStack || !this.parensStack.length)) {
+        return false;
+    }
+    if (this.math > Constants.Math.PARENS_DIVISION) {
+        return this.parensStack && this.parensStack.length;
+    }
+    return true;
 };
 
-contexts.Eval.prototype.isPathRelative = function (path) {
-    return !/^(?:[a-z-]+:|\/|#)/i.test(path);
+contexts.Eval.prototype.pathRequiresRewrite = function (path) {
+    var isRelative = this.rewriteUrls === Constants.RewriteUrls.LOCAL ? isPathLocalRelative : isPathRelative;
+
+    return isRelative(path);
+};
+
+contexts.Eval.prototype.rewritePath = function (path, rootpath) {
+    var newPath;
+
+    rootpath = rootpath || '';
+    newPath = this.normalizePath(rootpath + path);
+
+    // If a path was explicit relative and the rootpath was not an absolute path
+    // we must ensure that the new path is also explicit relative.
+    if (isPathLocalRelative(path) &&
+        isPathRelative(rootpath) &&
+        isPathLocalRelative(newPath) === false) {
+        newPath = './' + newPath;
+    }
+
+    return newPath;
 };
 
-contexts.Eval.prototype.normalizePath = function( path ) {
+contexts.Eval.prototype.normalizePath = function (path) {
     var
         segments = path.split('/').reverse(),
         segment;
 
     path = [];
-    while (segments.length !== 0 ) {
+    while (segments.length !== 0) {
         segment = segments.pop();
         switch ( segment ) {
             case '.':
@@ -120,7 +147,7 @@ contexts.Eval.prototype.normalizePath = function( path ) {
                 }
                 break;
             default:
-                path.push( segment );
+                path.push(segment);
                 break;
         }
     }
@@ -128,4 +155,12 @@ contexts.Eval.prototype.normalizePath = function( path ) {
     return path.join('/');
 };
 
+function isPathRelative(path) {
+    return !/^(?:[a-z-]+:|\/|#)/i.test(path);
+}
+
+function isPathLocalRelative(path) {
+    return path.charAt(0) === '.';
+}
+
 // todo - do the same for the toCSS ?

package/lib/less/default-options.js

@@ -1,10 +1,13 @@
 // Export a new default each time
 module.exports = function() {
     return {
+        /* Inline Javascript - @plugin still allowed */
+        javascriptEnabled: false,
+
         /* Outputs a makefile import dependency list to stdout. */
         depends: false,
 
-        /* Compress using less built-in compression. 
+        /* (DEPRECATED) Compress using less built-in compression. 
          * This does an okay job but does not utilise all the tricks of 
          * dedicated css compression. */
         compress: false,
@@ -39,13 +42,18 @@ module.exports = function() {
          * that references an image, exactly the same URL will be output in the css. 
          * This option allows you to re-write URL's in imported files so that the 
          * URL is always relative to the base imported file */
-        relativeUrls: false,
+        rewriteUrls: false,
 
         /* Compatibility with IE8. Used for limiting data-uri length */
         ieCompat: false,  // true until 3.0
 
-        /* Without this option on, Less will try and process all math in your css */
-        strictMath: false,
+        /* How to process math 
+         *   0 always           - eagerly try to solve all operations
+         *   1 parens-division  - require parens for division "/"
+         *   2 parens | strict  - require parens for all operations
+         *   3 strict-legacy    - legacy strict behavior (super-strict)
+         */
+        math: 0,
 
         /* Without this option, less attempts to guess at the output unit when it does maths. */
         strictUnits: false,

package/lib/less/functions/color.js

@@ -8,8 +8,17 @@ var Dimension = require('../tree/dimension'),
 function clamp(val) {
     return Math.min(1, Math.max(0, val));
 }
-function hsla(color) {
-    return colorFunctions.hsla(color.h, color.s, color.l, color.a);
+function hsla(origColor, hsl) {
+    var color = colorFunctions.hsla(hsl.h, hsl.s, hsl.l, hsl.a);
+    if (color) {
+        if (origColor.value && 
+            /^(rgb|hsl)/.test(origColor.value)) {
+            color.value = origColor.value;
+        } else {
+            color.value = 'rgb';
+        }
+        return color;
+    }
 }
 function number(n) {
     if (n instanceof Dimension) {
@@ -32,46 +41,79 @@ function scaled(n, size) {
 }
 colorFunctions = {
     rgb: function (r, g, b) {
-        return colorFunctions.rgba(r, g, b, 1.0);
+        var color = colorFunctions.rgba(r, g, b, 1.0);
+        if (color) {
+            color.value = 'rgb';
+            return color;
+        }
     },
     rgba: function (r, g, b, a) {
-        var rgb = [r, g, b].map(function (c) { return scaled(c, 255); });
-        a = number(a);
-        return new Color(rgb, a);
+        try {
+            if (r instanceof Color) {
+                if (g) {
+                    a = number(g);
+                } else {
+                    a = r.alpha;
+                }
+                return new Color(r.rgb, a, 'rgba');
+            }
+            var rgb = [r, g, b].map(function (c) { return scaled(c, 255); });
+            a = number(a);
+            return new Color(rgb, a, 'rgba');
+        }
+        catch (e) {}
     },
     hsl: function (h, s, l) {
-        return colorFunctions.hsla(h, s, l, 1.0);
+        var color = colorFunctions.hsla(h, s, l, 1.0);
+        if (color) {
+            color.value = 'hsl';
+            return color;
+        }
     },
     hsla: function (h, s, l, a) {
+        try {
+            if (h instanceof Color) {
+                if (s) {
+                    a = number(s);
+                } else {
+                    a = h.alpha;
+                }
+                return new Color(h.rgb, a, 'hsla');
+            }
 
-        var m1, m2;
+            var m1, m2;
 
-        function hue(h) {
-            h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
-            if (h * 6 < 1) {
-                return m1 + (m2 - m1) * h * 6;
-            }
-            else if (h * 2 < 1) {
-                return m2;
-            }
-            else if (h * 3 < 2) {
-                return m1 + (m2 - m1) * (2 / 3 - h) * 6;
-            }
-            else {
-                return m1;
+            function hue(h) {
+                h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
+                if (h * 6 < 1) {
+                    return m1 + (m2 - m1) * h * 6;
+                }
+                else if (h * 2 < 1) {
+                    return m2;
+                }
+                else if (h * 3 < 2) {
+                    return m1 + (m2 - m1) * (2 / 3 - h) * 6;
+                }
+                else {
+                    return m1;
+                }
             }
-        }
 
-        h = (number(h) % 360) / 360;
-        s = clamp(number(s)); l = clamp(number(l)); a = clamp(number(a));
+            h = (number(h) % 360) / 360;
+            s = clamp(number(s)); l = clamp(number(l)); a = clamp(number(a));
 
-        m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
-        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,
-            hue(h - 1 / 3) * 255,
-            a);
+            var rgb = [
+                hue(h + 1 / 3) * 255,
+                hue(h)       * 255,
+                hue(h - 1 / 3) * 255
+            ];
+            a = number(a);
+            return new Color(rgb, a, 'hsla');
+        }
+        catch (e) {}
     },
 
     hsv: function(h, s, v) {
@@ -159,7 +201,7 @@ colorFunctions = {
             hsl.s += amount.value / 100;
         }
         hsl.s = clamp(hsl.s);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     desaturate: function (color, amount, method) {
         var hsl = color.toHSL();
@@ -171,7 +213,7 @@ colorFunctions = {
             hsl.s -= amount.value / 100;
         }
         hsl.s = clamp(hsl.s);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     lighten: function (color, amount, method) {
         var hsl = color.toHSL();
@@ -183,7 +225,7 @@ colorFunctions = {
             hsl.l += amount.value / 100;
         }
         hsl.l = clamp(hsl.l);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     darken: function (color, amount, method) {
         var hsl = color.toHSL();
@@ -195,7 +237,7 @@ colorFunctions = {
             hsl.l -= amount.value / 100;
         }
         hsl.l = clamp(hsl.l);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     fadein: function (color, amount, method) {
         var hsl = color.toHSL();
@@ -207,7 +249,7 @@ colorFunctions = {
             hsl.a += amount.value / 100;
         }
         hsl.a = clamp(hsl.a);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     fadeout: function (color, amount, method) {
         var hsl = color.toHSL();
@@ -219,14 +261,14 @@ colorFunctions = {
             hsl.a -= amount.value / 100;
         }
         hsl.a = clamp(hsl.a);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     fade: function (color, amount) {
         var hsl = color.toHSL();
 
         hsl.a = amount.value / 100;
         hsl.a = clamp(hsl.a);
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     spin: function (color, amount) {
         var hsl = color.toHSL();
@@ -234,7 +276,7 @@ colorFunctions = {
 
         hsl.h = hue < 0 ? 360 + hue : hue;
 
-        return hsla(hsl);
+        return hsla(color, hsl);
     },
     //
     // Copyright (c) 2006-2009 Hampton Catlin, Natalie Weizenbaum, and Chris Eppstein
@@ -338,8 +380,9 @@ colorFunctions = {
     },
     color: function(c) {
         if ((c instanceof Quoted) &&
-            (/^#([a-f0-9]{6}|[a-f0-9]{3})$/i.test(c.value))) {
-            return new Color(c.value.slice(1));
+            (/^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})$/i.test(c.value))) {
+            var val = c.value.slice(1);
+            return new Color(val, undefined, '#' + val);
         }
         if ((c instanceof Color) || (c = Color.fromKeyword(c.value))) {
             c.value = undefined;
@@ -347,7 +390,7 @@ colorFunctions = {
         }
         throw {
             type:    'Argument',
-            message: 'argument must be a color keyword or 3/6 digit hex e.g. #FFF'
+            message: 'argument must be a color keyword or 3|4|6|8 digit hex e.g. #FFF'
         };
     },
     tint: function(color, amount) {

package/lib/less/functions/data-uri.js

@@ -18,7 +18,7 @@ module.exports = function(environment) {
         var mimetype = mimetypeNode && mimetypeNode.value;
         var filePath = filePathNode.value;
         var currentFileInfo = this.currentFileInfo;
-        var currentDirectory = currentFileInfo.relativeUrls ?
+        var currentDirectory = currentFileInfo.rewriteUrls ?
             currentFileInfo.currentDirectory : currentFileInfo.entryPath;
 
         var fragmentStart = filePath.indexOf('#');

package/lib/less/functions/index.js

@@ -10,6 +10,7 @@ module.exports = function(environment) {
     require('./color');
     require('./color-blending');
     require('./data-uri')(environment);
+    require('./list');
     require('./math');
     require('./number');
     require('./string');

package/lib/less/functions/list.js

@@ -0,0 +1,101 @@
+var Dimension = require('../tree/dimension'),
+    Declaration = require('../tree/declaration'),
+    Ruleset = require('../tree/ruleset'),
+    Selector = require('../tree/selector'),
+    Element = require('../tree/element'),
+    functionRegistry = require('./function-registry');
+
+var getItemsFromNode = function(node) {
+    // handle non-array values as an array of length 1
+    // return 'undefined' if index is invalid
+    var items = Array.isArray(node.value) ?
+        node.value : Array(node);
+
+    return items;
+};
+
+functionRegistry.addMultiple({
+    _SELF: function(n) {
+        return n;
+    },
+    extract: function(values, index) {
+        index = index.value - 1; // (1-based index)
+
+        return getItemsFromNode(values)[index];
+    },
+    length: function(values) {
+        return new Dimension(getItemsFromNode(values).length);
+    },
+    each: function(list, rs) {
+        var i = 0, rules = [], newRules, iterator;
+
+        if (list.value) {
+            if (Array.isArray(list.value)) {
+                iterator = list.value;
+            } else {
+                iterator = [list.value];
+            }
+        } else if (list.ruleset) {
+            iterator = list.ruleset.rules;
+        } else if (Array.isArray(list)) {
+            iterator = list;
+        } else {
+            iterator = [list];
+        }
+
+        var valueName = '@value',
+            keyName = '@key',
+            indexName = '@index';
+
+        if (rs.params) {
+            valueName = rs.params[0] && rs.params[0].name;
+            keyName = rs.params[1] && rs.params[1].name;
+            indexName = rs.params[2] && rs.params[2].name;
+            rs = rs.rules;
+        } else {
+            rs = rs.ruleset;
+        }
+        
+        iterator.forEach(function(item) {
+            i = i + 1;
+            var key, value;
+            if (item instanceof Declaration) {
+                key = typeof item.name === 'string' ? item.name : item.name[0].value;
+                value = item.value;
+            } else {
+                key = new Dimension(i);
+                value = item;
+            }
+
+            newRules = rs.rules.slice(0);
+            if (valueName) {
+                newRules.push(new Declaration(valueName,
+                    value,
+                    false, false, this.index, this.currentFileInfo));
+            }
+            if (indexName) {
+                newRules.push(new Declaration(indexName,
+                    new Dimension(i),
+                    false, false, this.index, this.currentFileInfo));
+            }
+            if (keyName) {
+                newRules.push(new Declaration(keyName,
+                    key,
+                    false, false, this.index, this.currentFileInfo));
+            }
+        
+            rules.push(new Ruleset([ new(Selector)([ new Element("", '&') ]) ],
+                newRules,
+                rs.strictImports,
+                rs.visibilityInfo()
+            ));
+        });
+
+        return new Ruleset([ new(Selector)([ new Element("", '&') ]) ],
+                rules,
+                rs.strictImports,
+                rs.visibilityInfo()
+            ).eval(this.context);
+
+    }
+});

package/lib/less/functions/types.js

@@ -20,15 +20,8 @@ var isa = function (n, Type) {
             throw { type: 'Argument', message: 'Second argument to isunit should be a unit or a string.' };
         }
         return (n instanceof Dimension) && n.unit.is(unit) ? Keyword.True : Keyword.False;
-    },
-    getItemsFromNode = function(node) {
-        // handle non-array values as an array of length 1
-        // return 'undefined' if index is invalid
-        var items = Array.isArray(node.value) ?
-            node.value : Array(node);
-
-        return items;
     };
+
 functionRegistry.addMultiple({
     isruleset: function (n) {
         return isa(n, DetachedRuleset);
@@ -77,16 +70,5 @@ functionRegistry.addMultiple({
     },
     'get-unit': function (n) {
         return new Anonymous(n.unit);
-    },
-    extract: function(values, index) {
-        index = index.value - 1; // (1-based index)
-
-        return getItemsFromNode(values)[index];
-    },
-    length: function(values) {
-        return new Dimension(getItemsFromNode(values).length);
-    },
-    _SELF: function(n) {
-        return n;
     }
 });

package/lib/less/import-manager.js

@@ -8,7 +8,7 @@ var contexts = require('./contexts'),
 module.exports = function(environment) {
 
     // FileInfo = {
-    //  'relativeUrls' - option - whether to adjust URL's to be relative
+    //  'rewriteUrls' - option - whether to adjust URL's to be relative
     //  'filename' - full resolved filename of current file
     //  'rootpath' - path to append to normal URLs for this node
     //  'currentDirectory' - path to the current file, absolute
@@ -65,7 +65,7 @@ module.exports = function(environment) {
         };
 
         var newFileInfo = {
-            relativeUrls: this.context.relativeUrls,
+            rewriteUrls: this.context.rewriteUrls,
             entryPath: currentFileInfo.entryPath,
             rootpath: currentFileInfo.rootpath,
             rootFilename: currentFileInfo.rootFilename
@@ -92,7 +92,7 @@ module.exports = function(environment) {
             // - If path of imported file is '../mixins.less' and rootpath is 'less/',
             //   then rootpath should become 'less/../'
             newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
-            if (newFileInfo.relativeUrls) {
+            if (newFileInfo.rewriteUrls) {
                 newFileInfo.rootpath = fileManager.join(
                     (importManager.context.rootpath || ''),
                     fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));

package/lib/less/index.js

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

package/lib/less/parse.js

@@ -10,10 +10,10 @@ module.exports = function(environment, ParseTree, ImportManager) {
 
         if (typeof options === 'function') {
             callback = options;
-            options = utils.defaults(this.options, {});
+            options = utils.copyOptions(this.options, {});
         }
         else {
-            options = utils.defaults(this.options, options || {});
+            options = utils.copyOptions(this.options, options || {});
         }
 
         if (!callback) {
@@ -46,7 +46,7 @@ module.exports = function(environment, ParseTree, ImportManager) {
                 var entryPath = filename.replace(/[^\/\\]*$/, '');
                 rootFileInfo = {
                     filename: filename,
-                    relativeUrls: context.relativeUrls,
+                    rewriteUrls: context.rewriteUrls,
                     rootpath: context.rootpath || '',
                     currentDirectory: entryPath,
                     entryPath: entryPath,