less 3.9.0 → 3.10.1

package/lib/less/tree/atrule.js

@@ -1,136 +1,165 @@
-var Node = require('./node'),
-    Selector = require('./selector'),
-    Ruleset = require('./ruleset'),
-    Anonymous = require('./anonymous');
-
-var AtRule = function (name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
-    var i;
-
-    this.name  = name;
-    this.value = (value instanceof Node) ? value : (value ? new Anonymous(value) : value);
-    if (rules) {
-        if (Array.isArray(rules)) {
-            this.rules = rules;
-        } else {
-            this.rules = [rules];
-            this.rules[0].selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
-        }
-        for (i = 0; i < this.rules.length; i++) {
-            this.rules[i].allowImports = true;
+import Node from './node';
+import Selector from './selector';
+import Ruleset from './ruleset';
+import Anonymous from './anonymous';
+
+class AtRule extends Node {
+    constructor(
+        name,
+        value,
+        rules,
+        index,
+        currentFileInfo,
+        debugInfo,
+        isRooted,
+        visibilityInfo
+    ) {
+        super();
+
+        let i;
+
+        this.name  = name;
+        this.value = (value instanceof Node) ? value : (value ? new Anonymous(value) : value);
+        if (rules) {
+            if (Array.isArray(rules)) {
+                this.rules = rules;
+            } else {
+                this.rules = [rules];
+                this.rules[0].selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
+            }
+            for (i = 0; i < this.rules.length; i++) {
+                this.rules[i].allowImports = true;
+            }
+            this.setParent(this.rules, this);
         }
-        this.setParent(this.rules, this);
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.debugInfo = debugInfo;
+        this.isRooted = isRooted || false;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
     }
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.debugInfo = debugInfo;
-    this.isRooted = isRooted || false;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-};
-
-AtRule.prototype = new Node();
-AtRule.prototype.type = 'AtRule';
-AtRule.prototype.accept = function (visitor) {
-    var value = this.value, rules = this.rules;
-    if (rules) {
-        this.rules = visitor.visitArray(rules);
-    }
-    if (value) {
-        this.value = visitor.visit(value);
-    }
-};
-AtRule.prototype.isRulesetLike = function() {
-    return this.rules || !this.isCharset();
-};
-AtRule.prototype.isCharset = function() {
-    return '@charset' === this.name;
-};
-AtRule.prototype.genCSS = function (context, output) {
-    var value = this.value, rules = this.rules;
-    output.add(this.name, this.fileInfo(), this.getIndex());
-    if (value) {
-        output.add(' ');
-        value.genCSS(context, output);
+
+    accept(visitor) {
+        const value = this.value;
+        const rules = this.rules;
+        if (rules) {
+            this.rules = visitor.visitArray(rules);
+        }
+        if (value) {
+            this.value = visitor.visit(value);
+        }
     }
-    if (rules) {
-        this.outputRuleset(context, output, rules);
-    } else {
-        output.add(';');
+
+    isRulesetLike() {
+        return this.rules || !this.isCharset();
     }
-};
-AtRule.prototype.eval = function (context) {
-    var mediaPathBackup, mediaBlocksBackup, value = this.value, rules = this.rules;
-
-    // media stored inside other atrule should not bubble over it
-    // backpup media bubbling information
-    mediaPathBackup = context.mediaPath;
-    mediaBlocksBackup = context.mediaBlocks;
-    // deleted media bubbling information
-    context.mediaPath = [];
-    context.mediaBlocks = [];
-
-    if (value) {
-        value = value.eval(context);
+
+    isCharset() {
+        return '@charset' === this.name;
     }
-    if (rules) {
-        // assuming that there is only one rule at this point - that is how parser constructs the rule
-        rules = [rules[0].eval(context)];
-        rules[0].root = true;
+
+    genCSS(context, output) {
+        const value = this.value;
+        const rules = this.rules;
+        output.add(this.name, this.fileInfo(), this.getIndex());
+        if (value) {
+            output.add(' ');
+            value.genCSS(context, output);
+        }
+        if (rules) {
+            this.outputRuleset(context, output, rules);
+        } else {
+            output.add(';');
+        }
     }
-    // restore media bubbling information
-    context.mediaPath = mediaPathBackup;
-    context.mediaBlocks = mediaBlocksBackup;
-
-    return new AtRule(this.name, value, rules,
-        this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
-};
-AtRule.prototype.variable = function (name) {
-    if (this.rules) {
-        // assuming that there is only one rule at this point - that is how parser constructs the rule
-        return Ruleset.prototype.variable.call(this.rules[0], name);
+
+    eval(context) {
+        let mediaPathBackup;
+        let mediaBlocksBackup;
+        let value = this.value;
+        let rules = this.rules;
+
+        // media stored inside other atrule should not bubble over it
+        // backpup media bubbling information
+        mediaPathBackup = context.mediaPath;
+        mediaBlocksBackup = context.mediaBlocks;
+        // deleted media bubbling information
+        context.mediaPath = [];
+        context.mediaBlocks = [];
+
+        if (value) {
+            value = value.eval(context);
+        }
+        if (rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            rules = [rules[0].eval(context)];
+            rules[0].root = true;
+        }
+        // restore media bubbling information
+        context.mediaPath = mediaPathBackup;
+        context.mediaBlocks = mediaBlocksBackup;
+
+        return new AtRule(this.name, value, rules,
+            this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
     }
-};
-AtRule.prototype.find = function () {
-    if (this.rules) {
-        // assuming that there is only one rule at this point - that is how parser constructs the rule
-        return Ruleset.prototype.find.apply(this.rules[0], arguments);
+
+    variable(name) {
+        if (this.rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            return Ruleset.prototype.variable.call(this.rules[0], name);
+        }
     }
-};
-AtRule.prototype.rulesets = function () {
-    if (this.rules) {
-        // assuming that there is only one rule at this point - that is how parser constructs the rule
-        return Ruleset.prototype.rulesets.apply(this.rules[0]);
+
+    find(...args) {
+        if (this.rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            return Ruleset.prototype.find.apply(this.rules[0], args);
+        }
     }
-};
-AtRule.prototype.outputRuleset = function (context, output, rules) {
-    var ruleCnt = rules.length, i;
-    context.tabLevel = (context.tabLevel | 0) + 1;
-
-    // Compressed
-    if (context.compress) {
-        output.add('{');
-        for (i = 0; i < ruleCnt; i++) {
-            rules[i].genCSS(context, output);
+
+    rulesets() {
+        if (this.rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            return Ruleset.prototype.rulesets.apply(this.rules[0]);
         }
-        output.add('}');
-        context.tabLevel--;
-        return;
     }
 
-    // Non-compressed
-    var tabSetStr = '\n' + Array(context.tabLevel).join('  '), tabRuleStr = tabSetStr + '  ';
-    if (!ruleCnt) {
-        output.add(' {' + tabSetStr + '}');
-    } else {
-        output.add(' {' + tabRuleStr);
-        rules[0].genCSS(context, output);
-        for (i = 1; i < ruleCnt; i++) {
-            output.add(tabRuleStr);
-            rules[i].genCSS(context, output);
+    outputRuleset(context, output, rules) {
+        const ruleCnt = rules.length;
+        let i;
+        context.tabLevel = (context.tabLevel | 0) + 1;
+
+        // Compressed
+        if (context.compress) {
+            output.add('{');
+            for (i = 0; i < ruleCnt; i++) {
+                rules[i].genCSS(context, output);
+            }
+            output.add('}');
+            context.tabLevel--;
+            return;
         }
-        output.add(tabSetStr + '}');
+
+        // Non-compressed
+        const tabSetStr = `\n${Array(context.tabLevel).join('  ')}`;
+
+        const tabRuleStr = `${tabSetStr}  `;
+        if (!ruleCnt) {
+            output.add(` {${tabSetStr}}`);
+        } else {
+            output.add(` {${tabRuleStr}`);
+            rules[0].genCSS(context, output);
+            for (i = 1; i < ruleCnt; i++) {
+                output.add(tabRuleStr);
+                rules[i].genCSS(context, output);
+            }
+            output.add(`${tabSetStr}}`);
+        }
+
+        context.tabLevel--;
     }
+}
 
-    context.tabLevel--;
-};
-module.exports = AtRule;
+AtRule.prototype.type = 'AtRule';
+export default AtRule;

package/lib/less/tree/attribute.js

@@ -1,27 +1,34 @@
-var Node = require('./node');
-
-var Attribute = function (key, op, value) {
-    this.key = key;
-    this.op = op;
-    this.value = value;
-};
-Attribute.prototype = new Node();
-Attribute.prototype.type = 'Attribute';
-Attribute.prototype.eval = function (context) {
-    return new Attribute(this.key.eval ? this.key.eval(context) : this.key,
-        this.op, (this.value && this.value.eval) ? this.value.eval(context) : this.value);
-};
-Attribute.prototype.genCSS = function (context, output) {
-    output.add(this.toCSS(context));
-};
-Attribute.prototype.toCSS = function (context) {
-    var value = this.key.toCSS ? this.key.toCSS(context) : this.key;
-
-    if (this.op) {
-        value += this.op;
-        value += (this.value.toCSS ? this.value.toCSS(context) : this.value);
+import Node from './node';
+
+class Attribute extends Node {
+    constructor(key, op, value) {
+        super();
+
+        this.key = key;
+        this.op = op;
+        this.value = value;
+    }
+
+    eval(context) {
+        return new Attribute(this.key.eval ? this.key.eval(context) : this.key,
+            this.op, (this.value && this.value.eval) ? this.value.eval(context) : this.value);
+    }
+
+    genCSS(context, output) {
+        output.add(this.toCSS(context));
+    }
+
+    toCSS(context) {
+        let value = this.key.toCSS ? this.key.toCSS(context) : this.key;
+
+        if (this.op) {
+            value += this.op;
+            value += (this.value.toCSS ? this.value.toCSS(context) : this.value);
+        }
+
+        return `[${value}]`;
     }
+}
 
-    return '[' + value + ']';
-};
-module.exports = Attribute;
+Attribute.prototype.type = 'Attribute';
+export default Attribute;

package/lib/less/tree/call.js

@@ -1,97 +1,105 @@
-var Node = require('./node'),
-    Anonymous = require('./anonymous'),
-    FunctionCaller = require('../functions/function-caller');
+import Node from './node';
+import Anonymous from './anonymous';
+import FunctionCaller from '../functions/function-caller';
+
 //
 // A function call node.
 //
-var Call = function (name, args, index, currentFileInfo) {
-    this.name = name;
-    this.args = args;
-    this.calc = name === 'calc';
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-Call.prototype = new Node();
-Call.prototype.type = 'Call';
-Call.prototype.accept = function (visitor) {
-    if (this.args) {
-        this.args = visitor.visitArray(this.args);
-    }
-};
-//
-// When evaluating a function call,
-// we either find the function in the functionRegistry,
-// in which case we call it, passing the  evaluated arguments,
-// if this returns null or we cannot find the function, we
-// simply print it out as it appeared originally [2].
-//
-// The reason why we evaluate the arguments, is in the case where
-// we try to pass a variable to a function, like: `saturate(@color)`.
-// The function should receive the value, not the variable.
-//
-Call.prototype.eval = function (context) {
-    /**
-     * Turn off math for calc(), and switch back on for evaluating nested functions
-     */
-    var currentMathContext = context.mathOn;
-    context.mathOn = !this.calc;
-    if (this.calc || context.inCalc) {
-        context.enterCalc();
+class Call extends Node {
+    constructor(name, args, index, currentFileInfo) {
+        super();
+
+        this.name = name;
+        this.args = args;
+        this.calc = name === 'calc';
+        this._index = index;
+        this._fileInfo = currentFileInfo;
     }
-    var args = this.args.map(function (a) { return a.eval(context); });
-    if (this.calc || context.inCalc) {
-        context.exitCalc();
+
+    accept(visitor) {
+        if (this.args) {
+            this.args = visitor.visitArray(this.args);
+        }
     }
-    context.mathOn = currentMathContext;
 
-    var result, funcCaller = new FunctionCaller(this.name, context, this.getIndex(), this.fileInfo());
-    
-    if (funcCaller.isValid()) {
-        try {
-            result = funcCaller.call(args);
-        } catch (e) {
-            throw { 
-                type: e.type || 'Runtime',
-                message: 'error evaluating function `' + this.name + '`' +
-                         (e.message ? ': ' + e.message : ''),
-                index: this.getIndex(), 
-                filename: this.fileInfo().filename,
-                line: e.lineNumber,
-                column: e.columnNumber
-            };
+    //
+    // When evaluating a function call,
+    // we either find the function in the functionRegistry,
+    // in which case we call it, passing the  evaluated arguments,
+    // if this returns null or we cannot find the function, we
+    // simply print it out as it appeared originally [2].
+    //
+    // The reason why we evaluate the arguments, is in the case where
+    // we try to pass a variable to a function, like: `saturate(@color)`.
+    // The function should receive the value, not the variable.
+    //
+    eval(context) {
+        /**
+         * Turn off math for calc(), and switch back on for evaluating nested functions
+         */
+        const currentMathContext = context.mathOn;
+        context.mathOn = !this.calc;
+        if (this.calc || context.inCalc) {
+            context.enterCalc();
         }
+        const args = this.args.map(a => a.eval(context));
+        if (this.calc || context.inCalc) {
+            context.exitCalc();
+        }
+        context.mathOn = currentMathContext;
 
-        if (result !== null && result !== undefined) {
-            // Results that that are not nodes are cast as Anonymous nodes
-            // Falsy values or booleans are returned as empty nodes
-            if (!(result instanceof Node)) {
-                if (!result || result === true) {
-                    result = new Anonymous(null); 
-                }
-                else {
-                    result = new Anonymous(result.toString()); 
+        let result;
+        const funcCaller = new FunctionCaller(this.name, context, this.getIndex(), this.fileInfo());
+
+        if (funcCaller.isValid()) {
+            try {
+                result = funcCaller.call(args);
+            } catch (e) {
+                throw { 
+                    type: e.type || 'Runtime',
+                    message: `error evaluating function \`${this.name}\`${e.message ? `: ${e.message}` : ''}`,
+                    index: this.getIndex(), 
+                    filename: this.fileInfo().filename,
+                    line: e.lineNumber,
+                    column: e.columnNumber
+                };
+            }
+
+            if (result !== null && result !== undefined) {
+                // Results that that are not nodes are cast as Anonymous nodes
+                // Falsy values or booleans are returned as empty nodes
+                if (!(result instanceof Node)) {
+                    if (!result || result === true) {
+                        result = new Anonymous(null); 
+                    }
+                    else {
+                        result = new Anonymous(result.toString()); 
+                    }
+                    
                 }
-                
+                result._index = this._index;
+                result._fileInfo = this._fileInfo;
+                return result;
             }
-            result._index = this._index;
-            result._fileInfo = this._fileInfo;
-            return result;
+
         }
 
+        return new Call(this.name, args, this.getIndex(), this.fileInfo());
     }
 
-    return new Call(this.name, args, this.getIndex(), this.fileInfo());
-};
-Call.prototype.genCSS = function (context, output) {
-    output.add(this.name + '(', this.fileInfo(), this.getIndex());
+    genCSS(context, output) {
+        output.add(`${this.name}(`, this.fileInfo(), this.getIndex());
 
-    for (var i = 0; i < this.args.length; i++) {
-        this.args[i].genCSS(context, output);
-        if (i + 1 < this.args.length) {
-            output.add(', ');
+        for (let i = 0; i < this.args.length; i++) {
+            this.args[i].genCSS(context, output);
+            if (i + 1 < this.args.length) {
+                output.add(', ');
+            }
         }
+
+        output.add(')');
     }
+}
 
-    output.add(')');
-};
-module.exports = Call;
+Call.prototype.type = 'Call';
+export default Call;