less 3.9.0 → 3.10.1

package/lib/less/tree/media.js

@@ -1,141 +1,154 @@
-var Ruleset = require('./ruleset'),
-    Value = require('./value'),
-    Selector = require('./selector'),
-    Anonymous = require('./anonymous'),
-    Expression = require('./expression'),
-    AtRule = require('./atrule'),
-    utils = require('../utils');
-
-var Media = function (value, features, index, currentFileInfo, visibilityInfo) {
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-
-    var selectors = (new Selector([], null, null, this._index, this._fileInfo)).createEmptySelectors();
-
-    this.features = new Value(features);
-    this.rules = [new Ruleset(selectors, value)];
-    this.rules[0].allowImports = true;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-    this.setParent(selectors, this);
-    this.setParent(this.features, this);
-    this.setParent(this.rules, this);
-};
-Media.prototype = new AtRule();
-Media.prototype.type = 'Media';
-Media.prototype.isRulesetLike = function() { return true; };
-Media.prototype.accept = function (visitor) {
-    if (this.features) {
-        this.features = visitor.visit(this.features);
+import Ruleset from './ruleset';
+import Value from './value';
+import Selector from './selector';
+import Anonymous from './anonymous';
+import Expression from './expression';
+import AtRule from './atrule';
+import * as utils from '../utils';
+
+class Media extends AtRule {
+    constructor(value, features, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+
+        const selectors = (new Selector([], null, null, this._index, this._fileInfo)).createEmptySelectors();
+
+        this.features = new Value(features);
+        this.rules = [new Ruleset(selectors, value)];
+        this.rules[0].allowImports = true;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+        this.setParent(selectors, this);
+        this.setParent(this.features, this);
+        this.setParent(this.rules, this);
     }
-    if (this.rules) {
-        this.rules = visitor.visitArray(this.rules);
+
+    isRulesetLike() {
+        return true;
     }
-};
-Media.prototype.genCSS = function (context, output) {
-    output.add('@media ', this._fileInfo, this._index);
-    this.features.genCSS(context, output);
-    this.outputRuleset(context, output, this.rules);
-};
-Media.prototype.eval = function (context) {
-    if (!context.mediaBlocks) {
-        context.mediaBlocks = [];
-        context.mediaPath = [];
+
+    accept(visitor) {
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
+        if (this.rules) {
+            this.rules = visitor.visitArray(this.rules);
+        }
     }
 
-    var media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
-    if (this.debugInfo) {
-        this.rules[0].debugInfo = this.debugInfo;
-        media.debugInfo = this.debugInfo;
+    genCSS(context, output) {
+        output.add('@media ', this._fileInfo, this._index);
+        this.features.genCSS(context, output);
+        this.outputRuleset(context, output, this.rules);
     }
-    
-    media.features = this.features.eval(context);
-
-    context.mediaPath.push(media);
-    context.mediaBlocks.push(media);
-
-    this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
-    context.frames.unshift(this.rules[0]);
-    media.rules = [this.rules[0].eval(context)];
-    context.frames.shift();
-
-    context.mediaPath.pop();
-
-    return context.mediaPath.length === 0 ? media.evalTop(context) :
-                media.evalNested(context);
-};
-Media.prototype.evalTop = function (context) {
-    var result = this;
-
-    // Render all dependent Media blocks.
-    if (context.mediaBlocks.length > 1) {
-        var selectors = (new Selector([], null, null, this.getIndex(), this.fileInfo())).createEmptySelectors();
-        result = new Ruleset(selectors, context.mediaBlocks);
-        result.multiMedia = true;
-        result.copyVisibilityInfo(this.visibilityInfo());
-        this.setParent(result, this);
+
+    eval(context) {
+        if (!context.mediaBlocks) {
+            context.mediaBlocks = [];
+            context.mediaPath = [];
+        }
+
+        const media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
+        if (this.debugInfo) {
+            this.rules[0].debugInfo = this.debugInfo;
+            media.debugInfo = this.debugInfo;
+        }
+        
+        media.features = this.features.eval(context);
+
+        context.mediaPath.push(media);
+        context.mediaBlocks.push(media);
+
+        this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
+        context.frames.unshift(this.rules[0]);
+        media.rules = [this.rules[0].eval(context)];
+        context.frames.shift();
+
+        context.mediaPath.pop();
+
+        return context.mediaPath.length === 0 ? media.evalTop(context) :
+            media.evalNested(context);
     }
 
-    delete context.mediaBlocks;
-    delete context.mediaPath;
+    evalTop(context) {
+        let result = this;
 
-    return result;
-};
-Media.prototype.evalNested = function (context) {
-    var i, value,
-        path = context.mediaPath.concat([this]);
+        // Render all dependent Media blocks.
+        if (context.mediaBlocks.length > 1) {
+            const selectors = (new Selector([], null, null, this.getIndex(), this.fileInfo())).createEmptySelectors();
+            result = new Ruleset(selectors, context.mediaBlocks);
+            result.multiMedia = true;
+            result.copyVisibilityInfo(this.visibilityInfo());
+            this.setParent(result, this);
+        }
 
-    // Extract the media-query conditions separated with `,` (OR).
-    for (i = 0; i < path.length; i++) {
-        value = path[i].features instanceof Value ?
-                    path[i].features.value : path[i].features;
-        path[i] = Array.isArray(value) ? value : [value];
+        delete context.mediaBlocks;
+        delete context.mediaPath;
+
+        return result;
     }
 
-    // Trace all permutations to generate the resulting media-query.
-    //
-    // (a, b and c) with nested (d, e) ->
-    //    a and d
-    //    a and e
-    //    b and c and d
-    //    b and c and e
-    this.features = new Value(this.permute(path).map(function (path) {
-        path = path.map(function (fragment) {
-            return fragment.toCSS ? fragment : new Anonymous(fragment);
-        });
-
-        for (i = path.length - 1; i > 0; i--) {
-            path.splice(i, 0, new Anonymous('and'));
+    evalNested(context) {
+        let i;
+        let value;
+        const path = context.mediaPath.concat([this]);
+
+        // Extract the media-query conditions separated with `,` (OR).
+        for (i = 0; i < path.length; i++) {
+            value = path[i].features instanceof Value ?
+                path[i].features.value : path[i].features;
+            path[i] = Array.isArray(value) ? value : [value];
         }
 
-        return new Expression(path);
-    }));
-    this.setParent(this.features, this);
-
-    // Fake a tree-node that doesn't output anything.
-    return new Ruleset([], []);
-};
-Media.prototype.permute = function (arr) {
-    if (arr.length === 0) {
-        return [];
-    } else if (arr.length === 1) {
-        return arr[0];
-    } else {
-        var result = [];
-        var rest = this.permute(arr.slice(1));
-        for (var i = 0; i < rest.length; i++) {
-            for (var j = 0; j < arr[0].length; j++) {
-                result.push([arr[0][j]].concat(rest[i]));
+        // Trace all permutations to generate the resulting media-query.
+        //
+        // (a, b and c) with nested (d, e) ->
+        //    a and d
+        //    a and e
+        //    b and c and d
+        //    b and c and e
+        this.features = new Value(this.permute(path).map(path => {
+            path = path.map(fragment => fragment.toCSS ? fragment : new Anonymous(fragment));
+
+            for (i = path.length - 1; i > 0; i--) {
+                path.splice(i, 0, new Anonymous('and'));
             }
+
+            return new Expression(path);
+        }));
+        this.setParent(this.features, this);
+
+        // Fake a tree-node that doesn't output anything.
+        return new Ruleset([], []);
+    }
+
+    permute(arr) {
+        if (arr.length === 0) {
+            return [];
+        } else if (arr.length === 1) {
+            return arr[0];
+        } else {
+            const result = [];
+            const rest = this.permute(arr.slice(1));
+            for (let i = 0; i < rest.length; i++) {
+                for (let j = 0; j < arr[0].length; j++) {
+                    result.push([arr[0][j]].concat(rest[i]));
+                }
+            }
+            return result;
         }
-        return result;
     }
-};
-Media.prototype.bubbleSelectors = function (selectors) {
-    if (!selectors) {
-        return;
+
+    bubbleSelectors(selectors) {
+        if (!selectors) {
+            return;
+        }
+        this.rules = [new Ruleset(utils.copyArray(selectors), [this.rules[0]])];
+        this.setParent(this.rules, this);
     }
-    this.rules = [new Ruleset(utils.copyArray(selectors), [this.rules[0]])];
-    this.setParent(this.rules, this);
-};
-module.exports = Media;
+}
+
+Media.prototype.type = 'Media';
+export default Media;

package/lib/less/tree/mixin-call.js

@@ -1,179 +1,205 @@
-var Node = require('./node'),
-    Selector = require('./selector'),
-    MixinDefinition = require('./mixin-definition'),
-    defaultFunc = require('../functions/default');
-
-var MixinCall = function (elements, args, index, currentFileInfo, important) {
-    this.selector = new Selector(elements);
-    this.arguments = args || [];
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.important = important;
-    this.allowRoot = true;
-    this.setParent(this.selector, this);
-};
-MixinCall.prototype = new Node();
-MixinCall.prototype.type = 'MixinCall';
-MixinCall.prototype.accept = function (visitor) {
-    if (this.selector) {
-        this.selector = visitor.visit(this.selector);
+import Node from './node';
+import Selector from './selector';
+import MixinDefinition from './mixin-definition';
+import defaultFunc from '../functions/default';
+
+class MixinCall extends Node {
+    constructor(elements, args, index, currentFileInfo, important) {
+        super();
+
+        this.selector = new Selector(elements);
+        this.arguments = args || [];
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.important = important;
+        this.allowRoot = true;
+        this.setParent(this.selector, this);
     }
-    if (this.arguments.length) {
-        this.arguments = visitor.visitArray(this.arguments);
+
+    accept(visitor) {
+        if (this.selector) {
+            this.selector = visitor.visit(this.selector);
+        }
+        if (this.arguments.length) {
+            this.arguments = visitor.visitArray(this.arguments);
+        }
     }
-};
-MixinCall.prototype.eval = function (context) {
-    var mixins, mixin, mixinPath, args = [], arg, argValue,
-        rules = [], match = false, i, m, f, isRecursive, isOneFound,
-        candidates = [], candidate, conditionResult = [], defaultResult, defFalseEitherCase = -1,
-        defNone = 0, defTrue = 1, defFalse = 2, count, originalRuleset, noArgumentsFilter;
-
-    this.selector = this.selector.eval(context);
-
-    function calcDefGroup(mixin, mixinPath) {
-        var f, p, namespace;
-
-        for (f = 0; f < 2; f++) {
-            conditionResult[f] = true;
-            defaultFunc.value(f);
-            for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
-                namespace = mixinPath[p];
-                if (namespace.matchCondition) {
-                    conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
+
+    eval(context) {
+        let mixins;
+        let mixin;
+        let mixinPath;
+        const args = [];
+        let arg;
+        let argValue;
+        const rules = [];
+        let match = false;
+        let i;
+        let m;
+        let f;
+        let isRecursive;
+        let isOneFound;
+        const candidates = [];
+        let candidate;
+        const conditionResult = [];
+        let defaultResult;
+        const defFalseEitherCase = -1;
+        const defNone = 0;
+        const defTrue = 1;
+        const defFalse = 2;
+        let count;
+        let originalRuleset;
+        let noArgumentsFilter;
+
+        this.selector = this.selector.eval(context);
+
+        function calcDefGroup(mixin, mixinPath) {
+            let f;
+            let p;
+            let namespace;
+
+            for (f = 0; f < 2; f++) {
+                conditionResult[f] = true;
+                defaultFunc.value(f);
+                for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
+                    namespace = mixinPath[p];
+                    if (namespace.matchCondition) {
+                        conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
+                    }
+                }
+                if (mixin.matchCondition) {
+                    conditionResult[f] = conditionResult[f] && mixin.matchCondition(args, context);
                 }
             }
-            if (mixin.matchCondition) {
-                conditionResult[f] = conditionResult[f] && mixin.matchCondition(args, context);
-            }
-        }
-        if (conditionResult[0] || conditionResult[1]) {
-            if (conditionResult[0] != conditionResult[1]) {
-                return conditionResult[1] ?
-                    defTrue : defFalse;
-            }
+            if (conditionResult[0] || conditionResult[1]) {
+                if (conditionResult[0] != conditionResult[1]) {
+                    return conditionResult[1] ?
+                        defTrue : defFalse;
+                }
 
-            return defNone;
+                return defNone;
+            }
+            return defFalseEitherCase;
         }
-        return defFalseEitherCase;
-    }
 
-    for (i = 0; i < this.arguments.length; i++) {
-        arg = this.arguments[i];
-        argValue = arg.value.eval(context);
-        if (arg.expand && Array.isArray(argValue.value)) {
-            argValue = argValue.value;
-            for (m = 0; m < argValue.length; m++) {
-                args.push({value: argValue[m]});
+        for (i = 0; i < this.arguments.length; i++) {
+            arg = this.arguments[i];
+            argValue = arg.value.eval(context);
+            if (arg.expand && Array.isArray(argValue.value)) {
+                argValue = argValue.value;
+                for (m = 0; m < argValue.length; m++) {
+                    args.push({value: argValue[m]});
+                }
+            } else {
+                args.push({name: arg.name, value: argValue});
             }
-        } else {
-            args.push({name: arg.name, value: argValue});
         }
-    }
 
-    noArgumentsFilter = function(rule) {return rule.matchArgs(null, context);};
-
-    for (i = 0; i < context.frames.length; i++) {
-        if ((mixins = context.frames[i].find(this.selector, null, noArgumentsFilter)).length > 0) {
-            isOneFound = true;
-
-            // To make `default()` function independent of definition order we have two "subpasses" here.
-            // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
-            // and build candidate list with corresponding flags. Then, when we know all possible matches,
-            // we make a final decision.
-
-            for (m = 0; m < mixins.length; m++) {
-                mixin = mixins[m].rule;
-                mixinPath = mixins[m].path;
-                isRecursive = false;
-                for (f = 0; f < context.frames.length; f++) {
-                    if ((!(mixin instanceof MixinDefinition)) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
-                        isRecursive = true;
-                        break;
+        noArgumentsFilter = rule => rule.matchArgs(null, context);
+
+        for (i = 0; i < context.frames.length; i++) {
+            if ((mixins = context.frames[i].find(this.selector, null, noArgumentsFilter)).length > 0) {
+                isOneFound = true;
+
+                // To make `default()` function independent of definition order we have two "subpasses" here.
+                // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
+                // and build candidate list with corresponding flags. Then, when we know all possible matches,
+                // we make a final decision.
+
+                for (m = 0; m < mixins.length; m++) {
+                    mixin = mixins[m].rule;
+                    mixinPath = mixins[m].path;
+                    isRecursive = false;
+                    for (f = 0; f < context.frames.length; f++) {
+                        if ((!(mixin instanceof MixinDefinition)) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
+                            isRecursive = true;
+                            break;
+                        }
+                    }
+                    if (isRecursive) {
+                        continue;
                     }
-                }
-                if (isRecursive) {
-                    continue;
-                }
 
-                if (mixin.matchArgs(args, context)) {
-                    candidate = {mixin: mixin, group: calcDefGroup(mixin, mixinPath)};
+                    if (mixin.matchArgs(args, context)) {
+                        candidate = {mixin, group: calcDefGroup(mixin, mixinPath)};
 
-                    if (candidate.group !== defFalseEitherCase) {
-                        candidates.push(candidate);
-                    }
+                        if (candidate.group !== defFalseEitherCase) {
+                            candidates.push(candidate);
+                        }
 
-                    match = true;
+                        match = true;
+                    }
                 }
-            }
 
-            defaultFunc.reset();
+                defaultFunc.reset();
 
-            count = [0, 0, 0];
-            for (m = 0; m < candidates.length; m++) {
-                count[candidates[m].group]++;
-            }
+                count = [0, 0, 0];
+                for (m = 0; m < candidates.length; m++) {
+                    count[candidates[m].group]++;
+                }
 
-            if (count[defNone] > 0) {
-                defaultResult = defFalse;
-            } else {
-                defaultResult = defTrue;
-                if ((count[defTrue] + count[defFalse]) > 1) {
-                    throw { type: 'Runtime',
-                        message: 'Ambiguous use of `default()` found when matching for `' + this.format(args) + '`',
-                        index: this.getIndex(), filename: this.fileInfo().filename };
+                if (count[defNone] > 0) {
+                    defaultResult = defFalse;
+                } else {
+                    defaultResult = defTrue;
+                    if ((count[defTrue] + count[defFalse]) > 1) {
+                        throw { type: 'Runtime',
+                            message: `Ambiguous use of \`default()\` found when matching for \`${this.format(args)}\``,
+                            index: this.getIndex(), filename: this.fileInfo().filename };
+                    }
                 }
-            }
 
-            for (m = 0; m < candidates.length; m++) {
-                candidate = candidates[m].group;
-                if ((candidate === defNone) || (candidate === defaultResult)) {
-                    try {
-                        mixin = candidates[m].mixin;
-                        if (!(mixin instanceof MixinDefinition)) {
-                            originalRuleset = mixin.originalRuleset || mixin;
-                            mixin = new MixinDefinition('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
-                            mixin.originalRuleset = originalRuleset;
+                for (m = 0; m < candidates.length; m++) {
+                    candidate = candidates[m].group;
+                    if ((candidate === defNone) || (candidate === defaultResult)) {
+                        try {
+                            mixin = candidates[m].mixin;
+                            if (!(mixin instanceof MixinDefinition)) {
+                                originalRuleset = mixin.originalRuleset || mixin;
+                                mixin = new MixinDefinition('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
+                                mixin.originalRuleset = originalRuleset;
+                            }
+                            const newRules = mixin.evalCall(context, args, this.important).rules;
+                            this._setVisibilityToReplacement(newRules);
+                            Array.prototype.push.apply(rules, newRules);
+                        } catch (e) {
+                            throw { message: e.message, index: this.getIndex(), filename: this.fileInfo().filename, stack: e.stack };
                         }
-                        var newRules = mixin.evalCall(context, args, this.important).rules;
-                        this._setVisibilityToReplacement(newRules);
-                        Array.prototype.push.apply(rules, newRules);
-                    } catch (e) {
-                        throw { message: e.message, index: this.getIndex(), filename: this.fileInfo().filename, stack: e.stack };
                     }
                 }
-            }
 
-            if (match) {
-                return rules;
+                if (match) {
+                    return rules;
+                }
             }
         }
+        if (isOneFound) {
+            throw { type:    'Runtime',
+                message: `No matching definition was found for \`${this.format(args)}\``,
+                index:   this.getIndex(), filename: this.fileInfo().filename };
+        } else {
+            throw { type:    'Name',
+                message: `${this.selector.toCSS().trim()} is undefined`,
+                index:   this.getIndex(), filename: this.fileInfo().filename };
+        }
     }
-    if (isOneFound) {
-        throw { type:    'Runtime',
-            message: 'No matching definition was found for `' + this.format(args) + '`',
-            index:   this.getIndex(), filename: this.fileInfo().filename };
-    } else {
-        throw { type:    'Name',
-            message: this.selector.toCSS().trim() + ' is undefined',
-            index:   this.getIndex(), filename: this.fileInfo().filename };
-    }
-};
-
-MixinCall.prototype._setVisibilityToReplacement = function (replacement) {
-    var i, rule;
-    if (this.blocksVisibility()) {
-        for (i = 0; i < replacement.length; i++) {
-            rule = replacement[i];
-            rule.addVisibilityBlock();
+
+    _setVisibilityToReplacement(replacement) {
+        let i;
+        let rule;
+        if (this.blocksVisibility()) {
+            for (i = 0; i < replacement.length; i++) {
+                rule = replacement[i];
+                rule.addVisibilityBlock();
+            }
         }
     }
-};
-MixinCall.prototype.format = function (args) {
-    return this.selector.toCSS().trim() + '(' +
-        (args ? args.map(function (a) {
-            var argValue = '';
+
+    format(args) {
+        return `${this.selector.toCSS().trim()}(${args ? args.map(a => {
+            let argValue = '';
             if (a.name) {
-                argValue += a.name + ':';
+                argValue += `${a.name}:`;
             }
             if (a.value.toCSS) {
                 argValue += a.value.toCSS();
@@ -181,6 +207,9 @@ MixinCall.prototype.format = function (args) {
                 argValue += '???';
             }
             return argValue;
-        }).join(', ') : '') + ')';
-};
-module.exports = MixinCall;
+        }).join(', ') : ''})`;
+    }
+}
+
+MixinCall.prototype.type = 'MixinCall';
+export default MixinCall;