less 3.9.0 → 3.10.1

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

@@ -1,209 +1,229 @@
-var Selector = require('./selector'),
-    Element = require('./element'),
-    Ruleset = require('./ruleset'),
-    Declaration = require('./declaration'),
-    DetachedRuleset = require('./detached-ruleset'),
-    Expression = require('./expression'),
-    contexts = require('../contexts'),
-    utils = require('../utils');
-
-var Definition = function (name, params, rules, condition, variadic, frames, visibilityInfo) {
-    this.name = name || 'anonymous mixin';
-    this.selectors = [new Selector([new Element(null, name, false, this._index, this._fileInfo)])];
-    this.params = params;
-    this.condition = condition;
-    this.variadic = variadic;
-    this.arity = params.length;
-    this.rules = rules;
-    this._lookups = {};
-    var optionalParameters = [];
-    this.required = params.reduce(function (count, p) {
-        if (!p.name || (p.name && !p.value)) {
-            return count + 1;
+import Selector from './selector';
+import Element from './element';
+import Ruleset from './ruleset';
+import Declaration from './declaration';
+import DetachedRuleset from './detached-ruleset';
+import Expression from './expression';
+import contexts from '../contexts';
+import * as utils from '../utils';
+
+class Definition extends Ruleset {
+    constructor(name, params, rules, condition, variadic, frames, visibilityInfo) {
+        super();
+
+        this.name = name || 'anonymous mixin';
+        this.selectors = [new Selector([new Element(null, name, false, this._index, this._fileInfo)])];
+        this.params = params;
+        this.condition = condition;
+        this.variadic = variadic;
+        this.arity = params.length;
+        this.rules = rules;
+        this._lookups = {};
+        const optionalParameters = [];
+        this.required = params.reduce((count, p) => {
+            if (!p.name || (p.name && !p.value)) {
+                return count + 1;
+            }
+            else {
+                optionalParameters.push(p.name);
+                return count;
+            }
+        }, 0);
+        this.optionalParameters = optionalParameters;
+        this.frames = frames;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+    }
+
+    accept(visitor) {
+        if (this.params && this.params.length) {
+            this.params = visitor.visitArray(this.params);
         }
-        else {
-            optionalParameters.push(p.name);
-            return count;
+        this.rules = visitor.visitArray(this.rules);
+        if (this.condition) {
+            this.condition = visitor.visit(this.condition);
         }
-    }, 0);
-    this.optionalParameters = optionalParameters;
-    this.frames = frames;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-};
-Definition.prototype = new Ruleset();
-Definition.prototype.type = 'MixinDefinition';
-Definition.prototype.evalFirst = true;
-Definition.prototype.accept = function (visitor) {
-    if (this.params && this.params.length) {
-        this.params = visitor.visitArray(this.params);
     }
-    this.rules = visitor.visitArray(this.rules);
-    if (this.condition) {
-        this.condition = visitor.visit(this.condition);
-    }
-};
-Definition.prototype.evalParams = function (context, mixinEnv, args, evaldArguments) {
-    /* jshint boss:true */
-    var frame = new Ruleset(null, null),
-        varargs, arg,
-        params = utils.copyArray(this.params),
-        i, j, val, name, isNamedFound, argIndex, argsLength = 0;
-
-    if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
-        frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
-    }
-    mixinEnv = new contexts.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
-
-    if (args) {
-        args = utils.copyArray(args);
-        argsLength = args.length;
-
-        for (i = 0; i < argsLength; i++) {
-            arg = args[i];
-            if (name = (arg && arg.name)) {
-                isNamedFound = false;
-                for (j = 0; j < params.length; j++) {
-                    if (!evaldArguments[j] && name === params[j].name) {
-                        evaldArguments[j] = arg.value.eval(context);
-                        frame.prependRule(new Declaration(name, arg.value.eval(context)));
-                        isNamedFound = true;
-                        break;
+
+    evalParams(context, mixinEnv, args, evaldArguments) {
+        /* jshint boss:true */
+        const frame = new Ruleset(null, null);
+
+        let varargs;
+        let arg;
+        const params = utils.copyArray(this.params);
+        let i;
+        let j;
+        let val;
+        let name;
+        let isNamedFound;
+        let argIndex;
+        let argsLength = 0;
+
+        if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
+            frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
+        }
+        mixinEnv = new contexts.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
+
+        if (args) {
+            args = utils.copyArray(args);
+            argsLength = args.length;
+
+            for (i = 0; i < argsLength; i++) {
+                arg = args[i];
+                if (name = (arg && arg.name)) {
+                    isNamedFound = false;
+                    for (j = 0; j < params.length; j++) {
+                        if (!evaldArguments[j] && name === params[j].name) {
+                            evaldArguments[j] = arg.value.eval(context);
+                            frame.prependRule(new Declaration(name, arg.value.eval(context)));
+                            isNamedFound = true;
+                            break;
+                        }
+                    }
+                    if (isNamedFound) {
+                        args.splice(i, 1);
+                        i--;
+                        continue;
+                    } else {
+                        throw { type: 'Runtime', message: `Named argument for ${this.name} ${args[i].name} not found` };
                     }
-                }
-                if (isNamedFound) {
-                    args.splice(i, 1);
-                    i--;
-                    continue;
-                } else {
-                    throw { type: 'Runtime', message: 'Named argument for ' + this.name +
-                        ' ' + args[i].name + ' not found' };
                 }
             }
         }
-    }
-    argIndex = 0;
-    for (i = 0; i < params.length; i++) {
-        if (evaldArguments[i]) { continue; }
+        argIndex = 0;
+        for (i = 0; i < params.length; i++) {
+            if (evaldArguments[i]) { continue; }
 
-        arg = args && args[argIndex];
+            arg = args && args[argIndex];
 
-        if (name = params[i].name) {
-            if (params[i].variadic) {
-                varargs = [];
-                for (j = argIndex; j < argsLength; j++) {
-                    varargs.push(args[j].value.eval(context));
-                }
-                frame.prependRule(new Declaration(name, new Expression(varargs).eval(context)));
-            } else {
-                val = arg && arg.value;
-                if (val) {
-                    // This was a mixin call, pass in a detached ruleset of it's eval'd rules
-                    if (Array.isArray(val)) {
-                        val = new DetachedRuleset(new Ruleset('', val));
-                    }
-                    else {
-                        val = val.eval(context);
+            if (name = params[i].name) {
+                if (params[i].variadic) {
+                    varargs = [];
+                    for (j = argIndex; j < argsLength; j++) {
+                        varargs.push(args[j].value.eval(context));
                     }
-                } else if (params[i].value) {
-                    val = params[i].value.eval(mixinEnv);
-                    frame.resetCache();
+                    frame.prependRule(new Declaration(name, new Expression(varargs).eval(context)));
                 } else {
-                    throw { type: 'Runtime', message: 'wrong number of arguments for ' + this.name +
-                        ' (' + argsLength + ' for ' + this.arity + ')' };
-                }
+                    val = arg && arg.value;
+                    if (val) {
+                        // This was a mixin call, pass in a detached ruleset of it's eval'd rules
+                        if (Array.isArray(val)) {
+                            val = new DetachedRuleset(new Ruleset('', val));
+                        }
+                        else {
+                            val = val.eval(context);
+                        }
+                    } else if (params[i].value) {
+                        val = params[i].value.eval(mixinEnv);
+                        frame.resetCache();
+                    } else {
+                        throw { type: 'Runtime', message: `wrong number of arguments for ${this.name} (${argsLength} for ${this.arity})` };
+                    }
 
-                frame.prependRule(new Declaration(name, val));
-                evaldArguments[i] = val;
+                    frame.prependRule(new Declaration(name, val));
+                    evaldArguments[i] = val;
+                }
             }
-        }
 
-        if (params[i].variadic && args) {
-            for (j = argIndex; j < argsLength; j++) {
-                evaldArguments[j] = args[j].value.eval(context);
+            if (params[i].variadic && args) {
+                for (j = argIndex; j < argsLength; j++) {
+                    evaldArguments[j] = args[j].value.eval(context);
+                }
             }
+            argIndex++;
         }
-        argIndex++;
+
+        return frame;
     }
 
-    return frame;
-};
-Definition.prototype.makeImportant = function() {
-    var rules = !this.rules ? this.rules : this.rules.map(function (r) {
-        if (r.makeImportant) {
-            return r.makeImportant(true);
-        } else {
-            return r;
-        }
-    });
-    var result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
-    return result;
-};
-Definition.prototype.eval = function (context) {
-    return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || utils.copyArray(context.frames));
-};
-Definition.prototype.evalCall = function (context, args, important) {
-    var _arguments = [],
-        mixinFrames = this.frames ? this.frames.concat(context.frames) : context.frames,
-        frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments),
-        rules, ruleset;
-
-    frame.prependRule(new Declaration('@arguments', new Expression(_arguments).eval(context)));
-
-    rules = utils.copyArray(this.rules);
-
-    ruleset = new Ruleset(null, rules);
-    ruleset.originalRuleset = this;
-    ruleset = ruleset.eval(new contexts.Eval(context, [this, frame].concat(mixinFrames)));
-    if (important) {
-        ruleset = ruleset.makeImportant();
+    makeImportant() {
+        const rules = !this.rules ? this.rules : this.rules.map(r => {
+            if (r.makeImportant) {
+                return r.makeImportant(true);
+            } else {
+                return r;
+            }
+        });
+        const result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
+        return result;
     }
-    return ruleset;
-};
-Definition.prototype.matchCondition = function (args, context) {
-    if (this.condition && !this.condition.eval(
-        new contexts.Eval(context,
-            [this.evalParams(context, /* the parameter variables */
-                new contexts.Eval(context, this.frames ? this.frames.concat(context.frames) : context.frames), args, [])]
-            .concat(this.frames || []) // the parent namespace/mixin frames
-            .concat(context.frames)))) { // the current environment frames
-        return false;
+
+    eval(context) {
+        return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || utils.copyArray(context.frames));
     }
-    return true;
-};
-Definition.prototype.matchArgs = function (args, context) {
-    var allArgsCnt = (args && args.length) || 0, len, optionalParameters = this.optionalParameters;
-    var requiredArgsCnt = !args ? 0 : args.reduce(function (count, p) {
-        if (optionalParameters.indexOf(p.name) < 0) {
-            return count + 1;
-        } else {
-            return count;
-        }
-    }, 0);
 
-    if (!this.variadic) {
-        if (requiredArgsCnt < this.required) {
-            return false;
-        }
-        if (allArgsCnt > this.params.length) {
-            return false;
+    evalCall(context, args, important) {
+        const _arguments = [];
+        const mixinFrames = this.frames ? this.frames.concat(context.frames) : context.frames;
+        const frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments);
+        let rules;
+        let ruleset;
+
+        frame.prependRule(new Declaration('@arguments', new Expression(_arguments).eval(context)));
+
+        rules = utils.copyArray(this.rules);
+
+        ruleset = new Ruleset(null, rules);
+        ruleset.originalRuleset = this;
+        ruleset = ruleset.eval(new contexts.Eval(context, [this, frame].concat(mixinFrames)));
+        if (important) {
+            ruleset = ruleset.makeImportant();
         }
-    } else {
-        if (requiredArgsCnt < (this.required - 1)) {
+        return ruleset;
+    }
+
+    matchCondition(args, context) {
+        if (this.condition && !this.condition.eval(
+            new contexts.Eval(context,
+                [this.evalParams(context, /* the parameter variables */
+                    new contexts.Eval(context, this.frames ? this.frames.concat(context.frames) : context.frames), args, [])]
+                    .concat(this.frames || []) // the parent namespace/mixin frames
+                    .concat(context.frames)))) { // the current environment frames
             return false;
         }
+        return true;
     }
 
-    // check patterns
-    len = Math.min(requiredArgsCnt, this.arity);
+    matchArgs(args, context) {
+        const allArgsCnt = (args && args.length) || 0;
+        let len;
+        const optionalParameters = this.optionalParameters;
+        const requiredArgsCnt = !args ? 0 : args.reduce((count, p) => {
+            if (optionalParameters.indexOf(p.name) < 0) {
+                return count + 1;
+            } else {
+                return count;
+            }
+        }, 0);
 
-    for (var i = 0; i < len; i++) {
-        if (!this.params[i].name && !this.params[i].variadic) {
-            if (args[i].value.eval(context).toCSS() != this.params[i].value.eval(context).toCSS()) {
+        if (!this.variadic) {
+            if (requiredArgsCnt < this.required) {
+                return false;
+            }
+            if (allArgsCnt > this.params.length) {
+                return false;
+            }
+        } else {
+            if (requiredArgsCnt < (this.required - 1)) {
                 return false;
             }
         }
+
+        // check patterns
+        len = Math.min(requiredArgsCnt, this.arity);
+
+        for (let i = 0; i < len; i++) {
+            if (!this.params[i].name && !this.params[i].variadic) {
+                if (args[i].value.eval(context).toCSS() != this.params[i].value.eval(context).toCSS()) {
+                    return false;
+                }
+            }
+        }
+        return true;
     }
-    return true;
-};
-module.exports = Definition;
+}
+
+Definition.prototype.type = 'MixinDefinition';
+Definition.prototype.evalFirst = true;
+export default Definition;

package/lib/less/tree/namespace-value.js

@@ -1,79 +1,87 @@
-var Node = require('./node'),
-    Variable = require('./variable'),
-    Ruleset = require('./ruleset'),
-    Selector = require('./selector');
+import Node from './node';
+import Variable from './variable';
+import Ruleset from './ruleset';
+import Selector from './selector';
 
-var NamespaceValue = function (ruleCall, lookups, important, index, fileInfo) {
-    this.value = ruleCall;
-    this.lookups = lookups;
-    this.important = important;
-    this._index = index;
-    this._fileInfo = fileInfo;
-};
-NamespaceValue.prototype = new Node();
-NamespaceValue.prototype.type = 'NamespaceValue';
-NamespaceValue.prototype.eval = function (context) {
-    var i, j, name, rules = this.value.eval(context);
-    
-    for (i = 0; i < this.lookups.length; i++) {
-        name = this.lookups[i];
+class NamespaceValue extends Node {
+    constructor(ruleCall, lookups, important, index, fileInfo) {
+        super();
 
-        /**
-         * Eval'd DRs return rulesets.
-         * Eval'd mixins return rules, so let's make a ruleset if we need it.
-         * We need to do this because of late parsing of values
-         */
-        if (Array.isArray(rules)) {
-            rules = new Ruleset([new Selector()], rules);
-        }
+        this.value = ruleCall;
+        this.lookups = lookups;
+        this.important = important;
+        this._index = index;
+        this._fileInfo = fileInfo;
+    }
 
-        if (name === '') {
-            rules = rules.lastDeclaration();
-        }
-        else if (name.charAt(0) === '@') {
-            if (name.charAt(1) === '@') {
-                name = '@' + new Variable(name.substr(1)).eval(context).value;
+    eval(context) {
+        let i;
+        let j;
+        let name;
+        let rules = this.value.eval(context);
+
+        for (i = 0; i < this.lookups.length; i++) {
+            name = this.lookups[i];
+
+            /**
+             * Eval'd DRs return rulesets.
+             * Eval'd mixins return rules, so let's make a ruleset if we need it.
+             * We need to do this because of late parsing of values
+             */
+            if (Array.isArray(rules)) {
+                rules = new Ruleset([new Selector()], rules);
             }
-            if (rules.variables) {
-                rules = rules.variable(name);
+
+            if (name === '') {
+                rules = rules.lastDeclaration();
             }
-            
-            if (!rules) {
-                throw { type: 'Name',
-                    message: 'variable ' + name + ' not found',
-                    filename: this.fileInfo().filename,
-                    index: this.getIndex() };
-            }
-        }
-        else {
-            if (name.substring(0, 2) === '$@') {
-                name = '$' + new Variable(name.substr(1)).eval(context).value;
+            else if (name.charAt(0) === '@') {
+                if (name.charAt(1) === '@') {
+                    name = `@${new Variable(name.substr(1)).eval(context).value}`;
+                }
+                if (rules.variables) {
+                    rules = rules.variable(name);
+                }
+                
+                if (!rules) {
+                    throw { type: 'Name',
+                        message: `variable ${name} not found`,
+                        filename: this.fileInfo().filename,
+                        index: this.getIndex() };
+                }
             }
             else {
-                name = name.charAt(0) === '$' ? name : '$' + name;
+                if (name.substring(0, 2) === '$@') {
+                    name = `$${new Variable(name.substr(1)).eval(context).value}`;
+                }
+                else {
+                    name = name.charAt(0) === '$' ? name : `$${name}`;
+                }
+                if (rules.properties) {
+                    rules = rules.property(name);
+                }
+            
+                if (!rules) {
+                    throw { type: 'Name',
+                        message: `property "${name.substr(1)}" not found`,
+                        filename: this.fileInfo().filename,
+                        index: this.getIndex() };
+                }
+                // Properties are an array of values, since a ruleset can have multiple props.
+                // We pick the last one (the "cascaded" value)
+                rules = rules[rules.length - 1];
             }
-            if (rules.properties) {
-                rules = rules.property(name);
+
+            if (rules.value) {
+                rules = rules.eval(context).value;
             }
-        
-            if (!rules) {
-                throw { type: 'Name',
-                    message: 'property "' + name.substr(1) + '" not found',
-                    filename: this.fileInfo().filename,
-                    index: this.getIndex() };
+            if (rules.ruleset) {
+                rules = rules.ruleset.eval(context);
             }
-            // Properties are an array of values, since a ruleset can have multiple props.
-            // We pick the last one (the "cascaded" value)
-            rules = rules[rules.length - 1];
-        }
-
-        if (rules.value) {
-            rules = rules.eval(context).value;
-        }
-        if (rules.ruleset) {
-            rules = rules.ruleset.eval(context);
         }
+        return rules;
     }
-    return rules;
-};
-module.exports = NamespaceValue;
+}
+
+NamespaceValue.prototype.type = 'NamespaceValue';
+export default NamespaceValue;

package/lib/less/tree/negative.js

@@ -1,20 +1,26 @@
-var Node = require('./node'),
-    Operation = require('./operation'),
-    Dimension = require('./dimension');
+import Node from './node';
+import Operation from './operation';
+import Dimension from './dimension';
 
-var Negative = function (node) {
-    this.value = node;
-};
-Negative.prototype = new Node();
-Negative.prototype.type = 'Negative';
-Negative.prototype.genCSS = function (context, output) {
-    output.add('-');
-    this.value.genCSS(context, output);
-};
-Negative.prototype.eval = function (context) {
-    if (context.isMathOn()) {
-        return (new Operation('*', [new Dimension(-1), this.value])).eval(context);
+class Negative extends Node {
+    constructor(node) {
+        super();
+
+        this.value = node;
+    }
+
+    genCSS(context, output) {
+        output.add('-');
+        this.value.genCSS(context, output);
     }
-    return new Negative(this.value.eval(context));
-};
-module.exports = Negative;
+
+    eval(context) {
+        if (context.isMathOn()) {
+            return (new Operation('*', [new Dimension(-1), this.value])).eval(context);
+        }
+        return new Negative(this.value.eval(context));
+    }
+}
+
+Negative.prototype.type = 'Negative';
+export default Negative;