less 3.9.0 → 3.10.1

package/lib/less/tree/element.js

@@ -1,64 +1,73 @@
-var Node = require('./node'),
-    Paren = require('./paren'),
-    Combinator = require('./combinator');
+import Node from './node';
+import Paren from './paren';
+import Combinator from './combinator';
 
-var Element = function (combinator, value, isVariable, index, currentFileInfo, visibilityInfo) {
-    this.combinator = combinator instanceof Combinator ?
-                      combinator : new Combinator(combinator);
+class Element extends Node {
+    constructor(combinator, value, isVariable, index, currentFileInfo, visibilityInfo) {
+        super();
 
-    if (typeof value === 'string') {
-        this.value = value.trim();
-    } else if (value) {
-        this.value = value;
-    } else {
-        this.value = '';
+        this.combinator = combinator instanceof Combinator ?
+            combinator : new Combinator(combinator);
+
+        if (typeof value === 'string') {
+            this.value = value.trim();
+        } else if (value) {
+            this.value = value;
+        } else {
+            this.value = '';
+        }
+        this.isVariable = isVariable;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.combinator, this);
     }
-    this.isVariable = isVariable;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.setParent(this.combinator, this);
-};
-Element.prototype = new Node();
-Element.prototype.type = 'Element';
-Element.prototype.accept = function (visitor) {
-    var value = this.value;
-    this.combinator = visitor.visit(this.combinator);
-    if (typeof value === 'object') {
-        this.value = visitor.visit(value);
+
+    accept(visitor) {
+        const value = this.value;
+        this.combinator = visitor.visit(this.combinator);
+        if (typeof value === 'object') {
+            this.value = visitor.visit(value);
+        }
     }
-};
-Element.prototype.eval = function (context) {
-    return new Element(this.combinator,
-                             this.value.eval ? this.value.eval(context) : this.value,
-                             this.isVariable,
-                             this.getIndex(),
-                             this.fileInfo(), this.visibilityInfo());
-};
-Element.prototype.clone = function () {
-    return new Element(this.combinator,
-        this.value,
-        this.isVariable,
-        this.getIndex(),
-        this.fileInfo(), this.visibilityInfo());
-};
-Element.prototype.genCSS = function (context, output) {
-    output.add(this.toCSS(context), this.fileInfo(), this.getIndex());
-};
-Element.prototype.toCSS = function (context) {
-    context = context || {};
-    var value = this.value, firstSelector = context.firstSelector;
-    if (value instanceof Paren) {
-        // selector in parens should not be affected by outer selector
-        // flags (breaks only interpolated selectors - see #1973)
-        context.firstSelector = true;
+
+    eval(context) {
+        return new Element(this.combinator,
+            this.value.eval ? this.value.eval(context) : this.value,
+            this.isVariable,
+            this.getIndex(),
+            this.fileInfo(), this.visibilityInfo());
     }
-    value = value.toCSS ? value.toCSS(context) : value;
-    context.firstSelector = firstSelector;
-    if (value === '' && this.combinator.value.charAt(0) === '&') {
-        return '';
-    } else {
-        return this.combinator.toCSS(context) + value;
+
+    clone() {
+        return new Element(this.combinator,
+            this.value,
+            this.isVariable,
+            this.getIndex(),
+            this.fileInfo(), this.visibilityInfo());
     }
-};
-module.exports = Element;
+
+    genCSS(context, output) {
+        output.add(this.toCSS(context), this.fileInfo(), this.getIndex());
+    }
+
+    toCSS(context = {}) {
+        let value = this.value;
+        const firstSelector = context.firstSelector;
+        if (value instanceof Paren) {
+            // selector in parens should not be affected by outer selector
+            // flags (breaks only interpolated selectors - see #1973)
+            context.firstSelector = true;
+        }
+        value = value.toCSS ? value.toCSS(context) : value;
+        context.firstSelector = firstSelector;
+        if (value === '' && this.combinator.value.charAt(0) === '&') {
+            return '';
+        } else {
+            return this.combinator.toCSS(context) + value;
+        }
+    }
+}
+
+Element.prototype.type = 'Element';
+export default Element;

package/lib/less/tree/expression.js

@@ -1,65 +1,74 @@
-var Node = require('./node'),
-    Paren = require('./paren'),
-    Comment = require('./comment'),
-    Dimension = require('./dimension'),
-    MATH = require('../constants').Math;
+import Node from './node';
+import Paren from './paren';
+import Comment from './comment';
+import Dimension from './dimension';
+import * as Constants from '../constants';
+const MATH = Constants.Math;
 
-var Expression = function (value, noSpacing) {
-    this.value = value;
-    this.noSpacing = noSpacing;
-    if (!value) {
-        throw new Error('Expression requires an array parameter');
+class Expression extends Node {
+    constructor(value, noSpacing) {
+        super();
+
+        this.value = value;
+        this.noSpacing = noSpacing;
+        if (!value) {
+            throw new Error('Expression requires an array parameter');
+        }
     }
-};
-Expression.prototype = new Node();
-Expression.prototype.type = 'Expression';
-Expression.prototype.accept = function (visitor) {
-    this.value = visitor.visitArray(this.value);
-};
-Expression.prototype.eval = function (context) {
-    var returnValue,
-        mathOn = context.isMathOn(),
-        inParenthesis = this.parens && 
-            (context.math !== MATH.STRICT_LEGACY || !this.parensInOp),
-        doubleParen = false;
-    if (inParenthesis) {
-        context.inParenthesis();
+
+    accept(visitor) {
+        this.value = visitor.visitArray(this.value);
     }
-    if (this.value.length > 1) {
-        returnValue = new Expression(this.value.map(function (e) {
-            if (!e.eval) {
-                return e;
+
+    eval(context) {
+        let returnValue;
+        const mathOn = context.isMathOn();
+
+        const inParenthesis = this.parens && 
+            (context.math !== MATH.STRICT_LEGACY || !this.parensInOp);
+
+        let doubleParen = false;
+        if (inParenthesis) {
+            context.inParenthesis();
+        }
+        if (this.value.length > 1) {
+            returnValue = new Expression(this.value.map(e => {
+                if (!e.eval) {
+                    return e;
+                }
+                return e.eval(context);
+            }), this.noSpacing);
+        } else if (this.value.length === 1) {
+            if (this.value[0].parens && !this.value[0].parensInOp && !context.inCalc) {
+                doubleParen = true;
             }
-            return e.eval(context);
-        }), this.noSpacing);
-    } else if (this.value.length === 1) {
-        if (this.value[0].parens && !this.value[0].parensInOp && !context.inCalc) {
-            doubleParen = true;
+            returnValue = this.value[0].eval(context);
+        } else {
+            returnValue = this;
         }
-        returnValue = this.value[0].eval(context);
-    } else {
-        returnValue = this;
-    }
-    if (inParenthesis) {
-        context.outOfParenthesis();
-    }
-    if (this.parens && this.parensInOp && !mathOn && !doubleParen 
-        && (!(returnValue instanceof Dimension))) {
-        returnValue = new Paren(returnValue);
+        if (inParenthesis) {
+            context.outOfParenthesis();
+        }
+        if (this.parens && this.parensInOp && !mathOn && !doubleParen 
+            && (!(returnValue instanceof Dimension))) {
+            returnValue = new Paren(returnValue);
+        }
+        return returnValue;
     }
-    return returnValue;
-};
-Expression.prototype.genCSS = function (context, output) {
-    for (var i = 0; i < this.value.length; i++) {
-        this.value[i].genCSS(context, output);
-        if (!this.noSpacing && i + 1 < this.value.length) {
-            output.add(' ');
+
+    genCSS(context, output) {
+        for (let i = 0; i < this.value.length; i++) {
+            this.value[i].genCSS(context, output);
+            if (!this.noSpacing && i + 1 < this.value.length) {
+                output.add(' ');
+            }
         }
     }
-};
-Expression.prototype.throwAwayComments = function () {
-    this.value = this.value.filter(function(v) {
-        return !(v instanceof Comment);
-    });
-};
-module.exports = Expression;
+
+    throwAwayComments() {
+        this.value = this.value.filter(v => !(v instanceof Comment));
+    }
+}
+
+Expression.prototype.type = 'Expression';
+export default Expression;

package/lib/less/tree/extend.js

@@ -1,58 +1,66 @@
-var Node = require('./node'),
-    Selector = require('./selector');
-
-var Extend = function Extend(selector, option, index, currentFileInfo, visibilityInfo) {
-    this.selector = selector;
-    this.option = option;
-    this.object_id = Extend.next_id++;
-    this.parent_ids = [this.object_id];
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-
-    switch (option) {
-        case 'all':
-            this.allowBefore = true;
-            this.allowAfter = true;
-            break;
-        default:
-            this.allowBefore = false;
-            this.allowAfter = false;
-            break;
+import Node from './node';
+import Selector from './selector';
+
+class Extend extends Node {
+    constructor(selector, option, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.selector = selector;
+        this.option = option;
+        this.object_id = Extend.next_id++;
+        this.parent_ids = [this.object_id];
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+
+        switch (option) {
+            case 'all':
+                this.allowBefore = true;
+                this.allowAfter = true;
+                break;
+            default:
+                this.allowBefore = false;
+                this.allowAfter = false;
+                break;
+        }
+        this.setParent(this.selector, this);
     }
-    this.setParent(this.selector, this);
-};
-Extend.next_id = 0;
 
-Extend.prototype = new Node();
-Extend.prototype.type = 'Extend';
-Extend.prototype.accept = function (visitor) {
-    this.selector = visitor.visit(this.selector);
-};
-Extend.prototype.eval = function (context) {
-    return new Extend(this.selector.eval(context), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-};
-Extend.prototype.clone = function (context) {
-    return new Extend(this.selector, this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-};
-// it concatenates (joins) all selectors in selector array
-Extend.prototype.findSelfSelectors = function (selectors) {
-    var selfElements = [],
-        i,
-        selectorElements;
-
-    for (i = 0; i < selectors.length; i++) {
-        selectorElements = selectors[i].elements;
-        // duplicate the logic in genCSS function inside the selector node.
-        // future TODO - move both logics into the selector joiner visitor
-        if (i > 0 && selectorElements.length && selectorElements[0].combinator.value === '') {
-            selectorElements[0].combinator.value = ' ';
+    accept(visitor) {
+        this.selector = visitor.visit(this.selector);
+    }
+
+    eval(context) {
+        return new Extend(this.selector.eval(context), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+    }
+
+    clone(context) {
+        return new Extend(this.selector, this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+    }
+
+    // it concatenates (joins) all selectors in selector array
+    findSelfSelectors(selectors) {
+        let selfElements = [];
+        let i;
+        let selectorElements;
+
+        for (i = 0; i < selectors.length; i++) {
+            selectorElements = selectors[i].elements;
+            // duplicate the logic in genCSS function inside the selector node.
+            // future TODO - move both logics into the selector joiner visitor
+            if (i > 0 && selectorElements.length && selectorElements[0].combinator.value === '') {
+                selectorElements[0].combinator.value = ' ';
+            }
+            selfElements = selfElements.concat(selectors[i].elements);
         }
-        selfElements = selfElements.concat(selectors[i].elements);
+
+        this.selfSelectors = [new Selector(selfElements)];
+        this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
     }
+}
+
+Extend.next_id = 0;
 
-    this.selfSelectors = [new Selector(selfElements)];
-    this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
-};
-module.exports = Extend;
+Extend.prototype.type = 'Extend';
+export default Extend;