less 3.9.0 → 3.10.1

package/lib/less/tree/color.js

@@ -1,219 +1,236 @@
-var Node = require('./node'),
-    colors = require('../data/colors');
+import Node from './node';
+import colors from '../data/colors';
 
 //
 // RGB Colors - #ff0014, #eee
 //
-var Color = function (rgb, a, originalForm) {
-    var self = this;
-    //
-    // The end goal here, is to parse the arguments
-    // into an integer triplet, such as `128, 255, 0`
-    //
-    // This facilitates operations and conversions.
-    //
-    if (Array.isArray(rgb)) {
-        this.rgb = rgb;
-    } else if (rgb.length >= 6) {
-        this.rgb = [];
-        rgb.match(/.{2}/g).map(function (c, i) {
-            if (i < 3) {
-                self.rgb.push(parseInt(c, 16));
-            } else {
-                self.alpha = (parseInt(c, 16)) / 255;
-            }
-        });
-    } else {
-        this.rgb = [];
-        rgb.split('').map(function (c, i) {
-            if (i < 3) {
-                self.rgb.push(parseInt(c + c, 16));
-            } else {
-                self.alpha = (parseInt(c + c, 16)) / 255;
-            }
-        });
-    }
-    this.alpha = this.alpha || (typeof a === 'number' ? a : 1);
-    if (typeof originalForm !== 'undefined') {
-        this.value = originalForm;
+class Color extends Node {
+    constructor(rgb, a, originalForm) {
+        super();
+
+        const self = this;
+        //
+        // The end goal here, is to parse the arguments
+        // into an integer triplet, such as `128, 255, 0`
+        //
+        // This facilitates operations and conversions.
+        //
+        if (Array.isArray(rgb)) {
+            this.rgb = rgb;
+        } else if (rgb.length >= 6) {
+            this.rgb = [];
+            rgb.match(/.{2}/g).map((c, i) => {
+                if (i < 3) {
+                    self.rgb.push(parseInt(c, 16));
+                } else {
+                    self.alpha = (parseInt(c, 16)) / 255;
+                }
+            });
+        } else {
+            this.rgb = [];
+            rgb.split('').map((c, i) => {
+                if (i < 3) {
+                    self.rgb.push(parseInt(c + c, 16));
+                } else {
+                    self.alpha = (parseInt(c + c, 16)) / 255;
+                }
+            });
+        }
+        this.alpha = this.alpha || (typeof a === 'number' ? a : 1);
+        if (typeof originalForm !== 'undefined') {
+            this.value = originalForm;
+        }
     }
-};
 
-Color.prototype = new Node();
-Color.prototype.type = 'Color';
+    luma() {
+        let r = this.rgb[0] / 255;
+        let g = this.rgb[1] / 255;
+        let b = this.rgb[2] / 255;
 
-function clamp(v, max) {
-    return Math.min(Math.max(v, 0), max);
-}
+        r = (r <= 0.03928) ? r / 12.92 : Math.pow(((r + 0.055) / 1.055), 2.4);
+        g = (g <= 0.03928) ? g / 12.92 : Math.pow(((g + 0.055) / 1.055), 2.4);
+        b = (b <= 0.03928) ? b / 12.92 : Math.pow(((b + 0.055) / 1.055), 2.4);
 
-function toHex(v) {
-    return '#' + v.map(function (c) {
-        c = clamp(Math.round(c), 255);
-        return (c < 16 ? '0' : '') + c.toString(16);
-    }).join('');
-}
-
-Color.prototype.luma = function () {
-    var r = this.rgb[0] / 255,
-        g = this.rgb[1] / 255,
-        b = this.rgb[2] / 255;
-
-    r = (r <= 0.03928) ? r / 12.92 : Math.pow(((r + 0.055) / 1.055), 2.4);
-    g = (g <= 0.03928) ? g / 12.92 : Math.pow(((g + 0.055) / 1.055), 2.4);
-    b = (b <= 0.03928) ? b / 12.92 : Math.pow(((b + 0.055) / 1.055), 2.4);
-
-    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-};
-Color.prototype.genCSS = function (context, output) {
-    output.add(this.toCSS(context));
-};
-Color.prototype.toCSS = function (context, doNotCompress) {
-    var compress = context && context.compress && !doNotCompress, color, alpha,
-        colorFunction, args = [];
+        return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    }
 
-    // `value` is set if this color was originally
-    // converted from a named color string so we need
-    // to respect this and try to output named color too.
-    alpha = this.fround(context, this.alpha);
+    genCSS(context, output) {
+        output.add(this.toCSS(context));
+    }
 
-    if (this.value) {
-        if (this.value.indexOf('rgb') === 0) {
-            if (alpha < 1) {
-                colorFunction = 'rgba';
-            }
-        } else if (this.value.indexOf('hsl') === 0) {
-            if (alpha < 1) {
-                colorFunction = 'hsla';
+    toCSS(context, doNotCompress) {
+        const compress = context && context.compress && !doNotCompress;
+        let color;
+        let alpha;
+        let colorFunction;
+        let args = [];
+
+        // `value` is set if this color was originally
+        // converted from a named color string so we need
+        // to respect this and try to output named color too.
+        alpha = this.fround(context, this.alpha);
+
+        if (this.value) {
+            if (this.value.indexOf('rgb') === 0) {
+                if (alpha < 1) {
+                    colorFunction = 'rgba';
+                }
+            } else if (this.value.indexOf('hsl') === 0) {
+                if (alpha < 1) {
+                    colorFunction = 'hsla';
+                } else {
+                    colorFunction = 'hsl';
+                }
             } else {
-                colorFunction = 'hsl';
+                return this.value;
             }
         } else {
-            return this.value;
+            if (alpha < 1) {
+                colorFunction = 'rgba';
+            }
         }
-    } else {
-        if (alpha < 1) {
-            colorFunction = 'rgba';
+
+        switch (colorFunction) {
+            case 'rgba':
+                args = this.rgb.map(c => clamp(Math.round(c), 255)).concat(clamp(alpha, 1));
+                break;
+            case 'hsla':
+                args.push(clamp(alpha, 1));
+            case 'hsl':
+                color = this.toHSL();
+                args = [
+                    this.fround(context, color.h),
+                    `${this.fround(context, color.s * 100)}%`,
+                    `${this.fround(context, color.l * 100)}%`
+                ].concat(args);
         }
-    }
 
-    switch (colorFunction) {
-        case 'rgba':
-            args = this.rgb.map(function (c) {
-                return clamp(Math.round(c), 255);
-            }).concat(clamp(alpha, 1));
-            break;
-        case 'hsla':
-            args.push(clamp(alpha, 1));
-        case 'hsl':
-            color = this.toHSL();
-            args = [
-                this.fround(context, color.h),
-                this.fround(context, color.s * 100) + '%',
-                this.fround(context, color.l * 100) + '%'
-            ].concat(args);
+        if (colorFunction) {
+            // Values are capped between `0` and `255`, rounded and zero-padded.
+            return `${colorFunction}(${args.join(`,${compress ? '' : ' '}`)})`;
+        }
+
+        color = this.toRGB();
+
+        if (compress) {
+            const splitcolor = color.split('');
+
+            // Convert color to short format
+            if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
+                color = `#${splitcolor[1]}${splitcolor[3]}${splitcolor[5]}`;
+            }
+        }
+
+        return color;
     }
 
-    if (colorFunction) {
-        // Values are capped between `0` and `255`, rounded and zero-padded.
-        return colorFunction + '(' + args.join(',' + (compress ? '' : ' ')) + ')';
+    //
+    // Operations have to be done per-channel, if not,
+    // channels will spill onto each other. Once we have
+    // our result, in the form of an integer triplet,
+    // we create a new Color node to hold the result.
+    //
+    operate(context, op, other) {
+        const rgb = new Array(3);
+        const alpha = this.alpha * (1 - other.alpha) + other.alpha;
+        for (let c = 0; c < 3; c++) {
+            rgb[c] = this._operate(context, op, this.rgb[c], other.rgb[c]);
+        }
+        return new Color(rgb, alpha);
     }
 
-    color = this.toRGB();
+    toRGB() {
+        return toHex(this.rgb);
+    }
 
-    if (compress) {
-        var splitcolor = color.split('');
+    toHSL() {
+        const r = this.rgb[0] / 255;
+        const g = this.rgb[1] / 255;
+        const b = this.rgb[2] / 255;
+        const a = this.alpha;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        let h;
+        let s;
+        const l = (max + min) / 2;
+        const d = max - min;
+
+        if (max === min) {
+            h = s = 0;
+        } else {
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
 
-        // Convert color to short format
-        if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
-            color = '#' + splitcolor[1] + splitcolor[3] + splitcolor[5];
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2;               break;
+                case b: h = (r - g) / d + 4;               break;
+            }
+            h /= 6;
         }
+        return { h: h * 360, s, l, a };
     }
 
-    return color;
-};
+    // Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+    toHSV() {
+        const r = this.rgb[0] / 255;
+        const g = this.rgb[1] / 255;
+        const b = this.rgb[2] / 255;
+        const a = this.alpha;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        let h;
+        let s;
+        const v = max;
+
+        const d = max - min;
+        if (max === 0) {
+            s = 0;
+        } else {
+            s = d / max;
+        }
 
-//
-// Operations have to be done per-channel, if not,
-// channels will spill onto each other. Once we have
-// our result, in the form of an integer triplet,
-// we create a new Color node to hold the result.
-//
-Color.prototype.operate = function (context, op, other) {
-    var rgb = new Array(3);
-    var alpha = this.alpha * (1 - other.alpha) + other.alpha;
-    for (var c = 0; c < 3; c++) {
-        rgb[c] = this._operate(context, op, this.rgb[c], other.rgb[c]);
-    }
-    return new Color(rgb, alpha);
-};
-Color.prototype.toRGB = function () {
-    return toHex(this.rgb);
-};
-Color.prototype.toHSL = function () {
-    var r = this.rgb[0] / 255,
-        g = this.rgb[1] / 255,
-        b = this.rgb[2] / 255,
-        a = this.alpha;
-
-    var max = Math.max(r, g, b), min = Math.min(r, g, b);
-    var h, s, l = (max + min) / 2, d = max - min;
-
-    if (max === min) {
-        h = s = 0;
-    } else {
-        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-
-        switch (max) {
-            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
-            case g: h = (b - r) / d + 2;               break;
-            case b: h = (r - g) / d + 4;               break;
+        if (max === min) {
+            h = 0;
+        } else {
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
+            }
+            h /= 6;
         }
-        h /= 6;
+        return { h: h * 360, s, v, a };
     }
-    return { h: h * 360, s: s, l: l, a: a };
-};
-// Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
-Color.prototype.toHSV = function () {
-    var r = this.rgb[0] / 255,
-        g = this.rgb[1] / 255,
-        b = this.rgb[2] / 255,
-        a = this.alpha;
-
-    var max = Math.max(r, g, b), min = Math.min(r, g, b);
-    var h, s, v = max;
-
-    var d = max - min;
-    if (max === 0) {
-        s = 0;
-    } else {
-        s = d / max;
+
+    toARGB() {
+        return toHex([this.alpha * 255].concat(this.rgb));
     }
 
-    if (max === min) {
-        h = 0;
-    } else {
-        switch (max) {
-            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
-            case g: h = (b - r) / d + 2; break;
-            case b: h = (r - g) / d + 4; break;
-        }
-        h /= 6;
+    compare(x) {
+        return (x.rgb &&
+            x.rgb[0] === this.rgb[0] &&
+            x.rgb[1] === this.rgb[1] &&
+            x.rgb[2] === this.rgb[2] &&
+            x.alpha  === this.alpha) ? 0 : undefined;
     }
-    return { h: h * 360, s: s, v: v, a: a };
-};
-Color.prototype.toARGB = function () {
-    return toHex([this.alpha * 255].concat(this.rgb));
-};
-Color.prototype.compare = function (x) {
-    return (x.rgb &&
-        x.rgb[0] === this.rgb[0] &&
-        x.rgb[1] === this.rgb[1] &&
-        x.rgb[2] === this.rgb[2] &&
-        x.alpha  === this.alpha) ? 0 : undefined;
-};
+}
+
+Color.prototype.type = 'Color';
+
+function clamp(v, max) {
+    return Math.min(Math.max(v, 0), max);
+}
+
+function toHex(v) {
+    return `#${v.map(c => {
+        c = clamp(Math.round(c), 255);
+        return (c < 16 ? '0' : '') + c.toString(16);
+    }).join('')}`;
+}
 
-Color.fromKeyword = function(keyword) {
-    var c, key = keyword.toLowerCase();
+Color.fromKeyword = keyword => {
+    let c;
+    const key = keyword.toLowerCase();
     if (colors.hasOwnProperty(key)) {
         c = new Color(colors[key].slice(1));
     }
@@ -226,4 +243,4 @@ Color.fromKeyword = function(keyword) {
         return c;
     }
 };
-module.exports = Color;
+export default Color;

package/lib/less/tree/combinator.js

@@ -1,23 +1,29 @@
-var Node = require('./node');
-
-var Combinator = function (value) {
-    if (value === ' ') {
-        this.value = ' ';
-        this.emptyOrWhitespace = true;
-    } else {
-        this.value = value ? value.trim() : '';
-        this.emptyOrWhitespace = this.value === '';
-    }
-};
-Combinator.prototype = new Node();
-Combinator.prototype.type = 'Combinator';
-var _noSpaceCombinators = {
+import Node from './node';
+const _noSpaceCombinators = {
     '': true,
     ' ': true,
     '|': true
 };
-Combinator.prototype.genCSS = function (context, output) {
-    var spaceOrEmpty = (context.compress || _noSpaceCombinators[this.value]) ? '' : ' ';
-    output.add(spaceOrEmpty + this.value + spaceOrEmpty);
-};
-module.exports = Combinator;
+
+class Combinator extends Node {
+    constructor(value) {
+        super();
+
+        if (value === ' ') {
+            this.value = ' ';
+            this.emptyOrWhitespace = true;
+        } else {
+            this.value = value ? value.trim() : '';
+            this.emptyOrWhitespace = this.value === '';
+        }
+    }
+
+    genCSS(context, output) {
+        const spaceOrEmpty = (context.compress || _noSpaceCombinators[this.value]) ? '' : ' ';
+        output.add(spaceOrEmpty + this.value + spaceOrEmpty);
+    }
+}
+
+Combinator.prototype.type = 'Combinator';
+
+export default Combinator;

package/lib/less/tree/comment.js

@@ -1,23 +1,29 @@
-var Node = require('./node'),
-    getDebugInfo = require('./debug-info');
+import Node from './node';
+import getDebugInfo from './debug-info';
 
-var Comment = function (value, isLineComment, index, currentFileInfo) {
-    this.value = value;
-    this.isLineComment = isLineComment;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.allowRoot = true;
-};
-Comment.prototype = new Node();
-Comment.prototype.type = 'Comment';
-Comment.prototype.genCSS = function (context, output) {
-    if (this.debugInfo) {
-        output.add(getDebugInfo(context, this), this.fileInfo(), this.getIndex());
+class Comment extends Node {
+    constructor(value, isLineComment, index, currentFileInfo) {
+        super();
+
+        this.value = value;
+        this.isLineComment = isLineComment;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.allowRoot = true;
+    }
+
+    genCSS(context, output) {
+        if (this.debugInfo) {
+            output.add(getDebugInfo(context, this), this.fileInfo(), this.getIndex());
+        }
+        output.add(this.value);
     }
-    output.add(this.value);
-};
-Comment.prototype.isSilent = function(context) {
-    var isCompressed = context.compress && this.value[2] !== '!';
-    return this.isLineComment || isCompressed;
-};
-module.exports = Comment;
+
+    isSilent(context) {
+        const isCompressed = context.compress && this.value[2] !== '!';
+        return this.isLineComment || isCompressed;
+    }
+}
+
+Comment.prototype.type = 'Comment';
+export default Comment;

package/lib/less/tree/condition.js

@@ -1,37 +1,43 @@
-var Node = require('./node');
+import Node from './node';
 
-var Condition = function (op, l, r, i, negate) {
-    this.op = op.trim();
-    this.lvalue = l;
-    this.rvalue = r;
-    this._index = i;
-    this.negate = negate;
-};
-Condition.prototype = new Node();
-Condition.prototype.type = 'Condition';
-Condition.prototype.accept = function (visitor) {
-    this.lvalue = visitor.visit(this.lvalue);
-    this.rvalue = visitor.visit(this.rvalue);
-};
-Condition.prototype.eval = function (context) {
-    var result = (function (op, a, b) {
-        switch (op) {
-            case 'and': return a && b;
-            case 'or':  return a || b;
-            default:
-                switch (Node.compare(a, b)) {
-                    case -1:
-                        return op === '<' || op === '=<' || op === '<=';
-                    case 0:
-                        return op === '=' || op === '>=' || op === '=<' || op === '<=';
-                    case 1:
-                        return op === '>' || op === '>=';
-                    default:
-                        return false;
-                }
-        }
-    })(this.op, this.lvalue.eval(context), this.rvalue.eval(context));
+class Condition extends Node {
+    constructor(op, l, r, i, negate) {
+        super();
+
+        this.op = op.trim();
+        this.lvalue = l;
+        this.rvalue = r;
+        this._index = i;
+        this.negate = negate;
+    }
+
+    accept(visitor) {
+        this.lvalue = visitor.visit(this.lvalue);
+        this.rvalue = visitor.visit(this.rvalue);
+    }
 
-    return this.negate ? !result : result;
-};
-module.exports = Condition;
+    eval(context) {
+        const result = ((op, a, b) => {
+            switch (op) {
+                case 'and': return a && b;
+                case 'or':  return a || b;
+                default:
+                    switch (Node.compare(a, b)) {
+                        case -1:
+                            return op === '<' || op === '=<' || op === '<=';
+                        case 0:
+                            return op === '=' || op === '>=' || op === '=<' || op === '<=';
+                        case 1:
+                            return op === '>' || op === '>=';
+                        default:
+                            return false;
+                    }
+            }
+        })(this.op, this.lvalue.eval(context), this.rvalue.eval(context));
+
+        return this.negate ? !result : result;
+    }
+}
+
+Condition.prototype.type = 'Condition';
+export default Condition;

package/lib/less/tree/debug-info.js

@@ -1,5 +1,5 @@
-var debugInfo = function(context, ctx, lineSeparator) {
-    var result = '';
+const debugInfo = (context, ctx, lineSeparator) => {
+    let result = '';
     if (context.dumpLineNumbers && !context.compress) {
         switch (context.dumpLineNumbers) {
             case 'comments':
@@ -16,23 +16,19 @@ var debugInfo = function(context, ctx, lineSeparator) {
     return result;
 };
 
-debugInfo.asComment = function(ctx) {
-    return '/* line ' + ctx.debugInfo.lineNumber + ', ' + ctx.debugInfo.fileName + ' */\n';
-};
+debugInfo.asComment = ctx => `/* line ${ctx.debugInfo.lineNumber}, ${ctx.debugInfo.fileName} */\n`;
 
-debugInfo.asMediaQuery = function(ctx) {
-    var filenameWithProtocol = ctx.debugInfo.fileName;
+debugInfo.asMediaQuery = ctx => {
+    let filenameWithProtocol = ctx.debugInfo.fileName;
     if (!/^[a-z]+:\/\//i.test(filenameWithProtocol)) {
-        filenameWithProtocol = 'file://' + filenameWithProtocol;
+        filenameWithProtocol = `file://${filenameWithProtocol}`;
     }
-    return '@media -sass-debug-info{filename{font-family:' +
-        filenameWithProtocol.replace(/([.:\/\\])/g, function (a) {
-            if (a == '\\') {
-                a = '\/';
-            }
-            return '\\' + a;
-        }) +
-        '}line{font-family:\\00003' + ctx.debugInfo.lineNumber + '}}\n';
+    return `@media -sass-debug-info{filename{font-family:${filenameWithProtocol.replace(/([.:\/\\])/g, a => {
+        if (a == '\\') {
+            a = '\/';
+        }
+        return `\\${a}`;
+    })}}line{font-family:\\00003${ctx.debugInfo.lineNumber}}}\n`;
 };
 
-module.exports = debugInfo;
+export default debugInfo;