less 3.9.0 → 3.10.1

package/lib/less/tree/node.js

@@ -1,72 +1,144 @@
-var Node = function() {
-    this.parent = null;
-    this.visibilityBlocks = undefined;
-    this.nodeVisible = undefined;
-    this.rootNode = null;
-    this.parsed = null;
-
-    var self = this;
-    Object.defineProperty(this, 'currentFileInfo', {
-        get: function() { return self.fileInfo(); }
-    });
-    Object.defineProperty(this, 'index', {
-        get: function() { return self.getIndex(); }
-    });
+class Node {
+    constructor() {
+        this.parent = null;
+        this.visibilityBlocks = undefined;
+        this.nodeVisible = undefined;
+        this.rootNode = null;
+        this.parsed = null;
 
-};
-Node.prototype.setParent = function(nodes, parent) {
-    function set(node) {
-        if (node && node instanceof Node) {
-            node.parent = parent;
+        const self = this;
+        Object.defineProperty(this, 'currentFileInfo', {
+            get: function() { return self.fileInfo(); }
+        });
+        Object.defineProperty(this, 'index', {
+            get: function() { return self.getIndex(); }
+        });
+
+    }
+
+    setParent(nodes, parent) {
+        function set(node) {
+            if (node && node instanceof Node) {
+                node.parent = parent;
+            }
         }
+        if (Array.isArray(nodes)) {
+            nodes.forEach(set);
+        }
+        else {
+            set(nodes);
+        }
+    }
+
+    getIndex() {
+        return this._index || (this.parent && this.parent.getIndex()) || 0;
     }
-    if (Array.isArray(nodes)) {
-        nodes.forEach(set);
+
+    fileInfo() {
+        return this._fileInfo || (this.parent && this.parent.fileInfo()) || {};
     }
-    else {
-        set(nodes);
+
+    isRulesetLike() {
+        return false;
     }
-};
-Node.prototype.getIndex = function() {
-    return this._index || (this.parent && this.parent.getIndex()) || 0;
-};
-Node.prototype.fileInfo = function() {
-    return this._fileInfo || (this.parent && this.parent.fileInfo()) || {};
-};
-Node.prototype.isRulesetLike = function() { return false; };
-Node.prototype.toCSS = function (context) {
-    var strs = [];
-    this.genCSS(context, {
-        add: function(chunk, fileInfo, index) {
-            strs.push(chunk);
-        },
-        isEmpty: function () {
-            return strs.length === 0;
+
+    toCSS(context) {
+        const strs = [];
+        this.genCSS(context, {
+            add: function(chunk, fileInfo, index) {
+                strs.push(chunk);
+            },
+            isEmpty: function () {
+                return strs.length === 0;
+            }
+        });
+        return strs.join('');
+    }
+
+    genCSS(context, output) {
+        output.add(this.value);
+    }
+
+    accept(visitor) {
+        this.value = visitor.visit(this.value);
+    }
+
+    eval() { return this; }
+
+    _operate(context, op, a, b) {
+        switch (op) {
+            case '+': return a + b;
+            case '-': return a - b;
+            case '*': return a * b;
+            case '/': return a / b;
         }
-    });
-    return strs.join('');
-};
-Node.prototype.genCSS = function (context, output) {
-    output.add(this.value);
-};
-Node.prototype.accept = function (visitor) {
-    this.value = visitor.visit(this.value);
-};
-Node.prototype.eval = function () { return this; };
-Node.prototype._operate = function (context, op, a, b) {
-    switch (op) {
-        case '+': return a + b;
-        case '-': return a - b;
-        case '*': return a * b;
-        case '/': return a / b;
     }
-};
-Node.prototype.fround = function(context, value) {
-    var precision = context && context.numPrecision;
-    // add "epsilon" to ensure numbers like 1.000000005 (represented as 1.000000004999...) are properly rounded:
-    return (precision) ? Number((value + 2e-16).toFixed(precision)) : value;
-};
-Node.compare = function (a, b) {
+
+    fround(context, value) {
+        const precision = context && context.numPrecision;
+        // add "epsilon" to ensure numbers like 1.000000005 (represented as 1.000000004999...) are properly rounded:
+        return (precision) ? Number((value + 2e-16).toFixed(precision)) : value;
+    }
+
+    // Returns true if this node represents root of ast imported by reference
+    blocksVisibility() {
+        if (this.visibilityBlocks == null) {
+            this.visibilityBlocks = 0;
+        }
+        return this.visibilityBlocks !== 0;
+    }
+
+    addVisibilityBlock() {
+        if (this.visibilityBlocks == null) {
+            this.visibilityBlocks = 0;
+        }
+        this.visibilityBlocks = this.visibilityBlocks + 1;
+    }
+
+    removeVisibilityBlock() {
+        if (this.visibilityBlocks == null) {
+            this.visibilityBlocks = 0;
+        }
+        this.visibilityBlocks = this.visibilityBlocks - 1;
+    }
+
+    // Turns on node visibility - if called node will be shown in output regardless
+    // of whether it comes from import by reference or not
+    ensureVisibility() {
+        this.nodeVisible = true;
+    }
+
+    // Turns off node visibility - if called node will NOT be shown in output regardless
+    // of whether it comes from import by reference or not
+    ensureInvisibility() {
+        this.nodeVisible = false;
+    }
+
+    // return values:
+    // false - the node must not be visible
+    // true - the node must be visible
+    // undefined or null - the node has the same visibility as its parent
+    isVisible() {
+        return this.nodeVisible;
+    }
+
+    visibilityInfo() {
+        return {
+            visibilityBlocks: this.visibilityBlocks,
+            nodeVisible: this.nodeVisible
+        };
+    }
+
+    copyVisibilityInfo(info) {
+        if (!info) {
+            return;
+        }
+        this.visibilityBlocks = info.visibilityBlocks;
+        this.nodeVisible = info.nodeVisible;
+    }
+}
+
+Node.compare = (a, b) => {
     /* returns:
      -1: a < b
      0: a = b
@@ -92,7 +164,7 @@ Node.compare = function (a, b) {
     if (a.length !== b.length) {
         return undefined;
     }
-    for (var i = 0; i < a.length; i++) {
+    for (let i = 0; i < a.length; i++) {
         if (Node.compare(a[i], b[i]) !== 0) {
             return undefined;
         }
@@ -100,58 +172,7 @@ Node.compare = function (a, b) {
     return 0;
 };
 
-Node.numericCompare = function (a, b) {
-    return a  <  b ? -1
-        : a === b ?  0
+Node.numericCompare = (a, b) => a  <  b ? -1
+    : a === b ?  0
         : a  >  b ?  1 : undefined;
-};
-// Returns true if this node represents root of ast imported by reference
-Node.prototype.blocksVisibility = function () {
-    if (this.visibilityBlocks == null) {
-        this.visibilityBlocks = 0;
-    }
-    return this.visibilityBlocks !== 0;
-};
-Node.prototype.addVisibilityBlock = function () {
-    if (this.visibilityBlocks == null) {
-        this.visibilityBlocks = 0;
-    }
-    this.visibilityBlocks = this.visibilityBlocks + 1;
-};
-Node.prototype.removeVisibilityBlock = function () {
-    if (this.visibilityBlocks == null) {
-        this.visibilityBlocks = 0;
-    }
-    this.visibilityBlocks = this.visibilityBlocks - 1;
-};
-// Turns on node visibility - if called node will be shown in output regardless
-// of whether it comes from import by reference or not
-Node.prototype.ensureVisibility = function () {
-    this.nodeVisible = true;
-};
-// Turns off node visibility - if called node will NOT be shown in output regardless
-// of whether it comes from import by reference or not
-Node.prototype.ensureInvisibility = function () {
-    this.nodeVisible = false;
-};
-// return values:
-// false - the node must not be visible
-// true - the node must be visible
-// undefined or null - the node has the same visibility as its parent
-Node.prototype.isVisible = function () {
-    return this.nodeVisible;
-};
-Node.prototype.visibilityInfo = function() {
-    return {
-        visibilityBlocks: this.visibilityBlocks,
-        nodeVisible: this.nodeVisible
-    };
-};
-Node.prototype.copyVisibilityInfo = function(info) {
-    if (!info) {
-        return;
-    }
-    this.visibilityBlocks = info.visibilityBlocks;
-    this.nodeVisible = info.nodeVisible;
-};
-module.exports = Node;
+export default Node;

package/lib/less/tree/operation.js

@@ -1,54 +1,62 @@
-var Node = require('./node'),
-    Color = require('./color'),
-    Dimension = require('./dimension'),
-    MATH = require('../constants').Math;
-
-var Operation = function (op, operands, isSpaced) {
-    this.op = op.trim();
-    this.operands = operands;
-    this.isSpaced = isSpaced;
-};
-Operation.prototype = new Node();
-Operation.prototype.type = 'Operation';
-Operation.prototype.accept = function (visitor) {
-    this.operands = visitor.visit(this.operands);
-};
-Operation.prototype.eval = function (context) {
-    var a = this.operands[0].eval(context),
-        b = this.operands[1].eval(context),
-        op;
-
-    if (context.isMathOn(this.op)) {
-        op = this.op === './' ? '/' : this.op;
-        if (a instanceof Dimension && b instanceof Color) {
-            a = a.toColor();
-        }
-        if (b instanceof Dimension && a instanceof Color) {
-            b = b.toColor();
-        }
-        if (!a.operate) {
-            if (a instanceof Operation && a.op === '/' && context.math === MATH.PARENS_DIVISION) {
-                return new Operation(this.op, [a, b], this.isSpaced);
-            }
-            throw { type: 'Operation',
-                message: 'Operation on an invalid type' };
-        }
+import Node from './node';
+import Color from './color';
+import Dimension from './dimension';
+import * as Constants from '../constants';
+const MATH = Constants.Math;
 
-        return a.operate(context, op, b);
-    } else {
-        return new Operation(this.op, [a, b], this.isSpaced);
+
+class Operation extends Node {
+    constructor(op, operands, isSpaced) {
+        super();
+
+        this.op = op.trim();
+        this.operands = operands;
+        this.isSpaced = isSpaced;
     }
-};
-Operation.prototype.genCSS = function (context, output) {
-    this.operands[0].genCSS(context, output);
-    if (this.isSpaced) {
-        output.add(' ');
+
+    accept(visitor) {
+        this.operands = visitor.visitArray(this.operands);
+    }
+
+    eval(context) {
+        let a = this.operands[0].eval(context);
+        let b = this.operands[1].eval(context);
+        let op;
+
+        if (context.isMathOn(this.op)) {
+            op = this.op === './' ? '/' : this.op;
+            if (a instanceof Dimension && b instanceof Color) {
+                a = a.toColor();
+            }
+            if (b instanceof Dimension && a instanceof Color) {
+                b = b.toColor();
+            }
+            if (!a.operate) {
+                if (a instanceof Operation && a.op === '/' && context.math === MATH.PARENS_DIVISION) {
+                    return new Operation(this.op, [a, b], this.isSpaced);
+                }
+                throw { type: 'Operation',
+                    message: 'Operation on an invalid type' };
+            }
+
+            return a.operate(context, op, b);
+        } else {
+            return new Operation(this.op, [a, b], this.isSpaced);
+        }
     }
-    output.add(this.op);
-    if (this.isSpaced) {
-        output.add(' ');
+
+    genCSS(context, output) {
+        this.operands[0].genCSS(context, output);
+        if (this.isSpaced) {
+            output.add(' ');
+        }
+        output.add(this.op);
+        if (this.isSpaced) {
+            output.add(' ');
+        }
+        this.operands[1].genCSS(context, output);
     }
-    this.operands[1].genCSS(context, output);
-};
+}
 
-module.exports = Operation;
+Operation.prototype.type = 'Operation';
+export default Operation;

package/lib/less/tree/paren.js

@@ -1,16 +1,22 @@
-var Node = require('./node');
+import Node from './node';
+
+class Paren extends Node {
+    constructor(node) {
+        super();
+
+        this.value = node;
+    }
+
+    genCSS(context, output) {
+        output.add('(');
+        this.value.genCSS(context, output);
+        output.add(')');
+    }
+
+    eval(context) {
+        return new Paren(this.value.eval(context));
+    }
+}
 
-var Paren = function (node) {
-    this.value = node;
-};
-Paren.prototype = new Node();
 Paren.prototype.type = 'Paren';
-Paren.prototype.genCSS = function (context, output) {
-    output.add('(');
-    this.value.genCSS(context, output);
-    output.add(')');
-};
-Paren.prototype.eval = function (context) {
-    return new Paren(this.value.eval(context));
-};
-module.exports = Paren;
+export default Paren;

package/lib/less/tree/property.js

@@ -1,70 +1,77 @@
-var Node = require('./node'),
-    Declaration = require('./declaration');
+import Node from './node';
+import Declaration from './declaration';
 
-var Property = function (name, index, currentFileInfo) {
-    this.name = name;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-Property.prototype = new Node();
-Property.prototype.type = 'Property';
-Property.prototype.eval = function (context) {
-    var property, name = this.name;
-    // TODO: shorten this reference
-    var mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
+class Property extends Node {
+    constructor(name, index, currentFileInfo) {
+        super();
 
-    if (this.evaluating) {
-        throw { type: 'Name',
-            message: 'Recursive property reference for ' + name,
-            filename: this.fileInfo().filename,
-            index: this.getIndex() };
+        this.name = name;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
     }
 
-    this.evaluating = true;
+    eval(context) {
+        let property;
+        const name = this.name;
+        // TODO: shorten this reference
+        const mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
+
+        if (this.evaluating) {
+            throw { type: 'Name',
+                message: `Recursive property reference for ${name}`,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
 
-    property = this.find(context.frames, function (frame) {
+        this.evaluating = true;
 
-        var v, vArr = frame.property(name);
-        if (vArr) {
-            for (var i = 0; i < vArr.length; i++) {
-                v = vArr[i];
+        property = this.find(context.frames, frame => {
+            let v;
+            const vArr = frame.property(name);
+            if (vArr) {
+                for (let i = 0; i < vArr.length; i++) {
+                    v = vArr[i];
 
-                vArr[i] = new Declaration(v.name,
-                    v.value,
-                    v.important,
-                    v.merge,
-                    v.index,
-                    v.currentFileInfo,
-                    v.inline,
-                    v.variable
-                );
-            }
-            mergeRules(vArr);
+                    vArr[i] = new Declaration(v.name,
+                        v.value,
+                        v.important,
+                        v.merge,
+                        v.index,
+                        v.currentFileInfo,
+                        v.inline,
+                        v.variable
+                    );
+                }
+                mergeRules(vArr);
 
-            v = vArr[vArr.length - 1];
-            if (v.important) {
-                var importantScope = context.importantScope[context.importantScope.length - 1];
-                importantScope.important = v.important;
+                v = vArr[vArr.length - 1];
+                if (v.important) {
+                    const importantScope = context.importantScope[context.importantScope.length - 1];
+                    importantScope.important = v.important;
+                }
+                v = v.value.eval(context);
+                return v;
             }
-            v = v.value.eval(context);
-            return v;
+        });
+        if (property) {
+            this.evaluating = false;
+            return property;
+        } else {
+            throw { type: 'Name',
+                message: `Property '${name}' is undefined`,
+                filename: this.currentFileInfo.filename,
+                index: this.index };
         }
-    });
-    if (property) {
-        this.evaluating = false;
-        return property;
-    } else {
-        throw { type: 'Name',
-            message: 'Property \'' + name + '\' is undefined',
-            filename: this.currentFileInfo.filename,
-            index: this.index };
     }
-};
-Property.prototype.find = function (obj, fun) {
-    for (var i = 0, r; i < obj.length; i++) {
-        r = fun.call(obj, obj[i]);
-        if (r) { return r; }
+
+    find(obj, fun) {
+        for (let i = 0, r; i < obj.length; i++) {
+            r = fun.call(obj, obj[i]);
+            if (r) { return r; }
+        }
+        return null;
     }
-    return null;
-};
-module.exports = Property;
+}
+
+Property.prototype.type = 'Property';
+export default Property;