less 3.9.0 → 3.10.1

package/lib/less/tree/value.js

@@ -1,39 +1,44 @@
-var Node = require('./node');
+import Node from './node';
 
-var Value = function (value) {
-    if (!value) {
-        throw new Error('Value requires an array argument');
-    }
-    if (!Array.isArray(value)) {
-        this.value = [ value ];
-    }
-    else {
-        this.value = value;
+class Value extends Node {
+    constructor(value) {
+        super();
+
+        if (!value) {
+            throw new Error('Value requires an array argument');
+        }
+        if (!Array.isArray(value)) {
+            this.value = [ value ];
+        }
+        else {
+            this.value = value;
+        }
     }
-};
-Value.prototype = new Node();
-Value.prototype.type = 'Value';
-Value.prototype.accept = function (visitor) {
-    if (this.value) {
-        this.value = visitor.visitArray(this.value);
+
+    accept(visitor) {
+        if (this.value) {
+            this.value = visitor.visitArray(this.value);
+        }
     }
-};
-Value.prototype.eval = function (context) {
-    if (this.value.length === 1) {
-        return this.value[0].eval(context);
-    } else {
-        return new Value(this.value.map(function (v) {
-            return v.eval(context);
-        }));
+
+    eval(context) {
+        if (this.value.length === 1) {
+            return this.value[0].eval(context);
+        } else {
+            return new Value(this.value.map(v => v.eval(context)));
+        }
     }
-};
-Value.prototype.genCSS = function (context, output) {
-    var i;
-    for (i = 0; i < this.value.length; i++) {
-        this.value[i].genCSS(context, output);
-        if (i + 1 < this.value.length) {
-            output.add((context && context.compress) ? ',' : ', ');
+
+    genCSS(context, output) {
+        let i;
+        for (i = 0; i < this.value.length; i++) {
+            this.value[i].genCSS(context, output);
+            if (i + 1 < this.value.length) {
+                output.add((context && context.compress) ? ',' : ', ');
+            }
         }
     }
-};
-module.exports = Value;
+}
+
+Value.prototype.type = 'Value';
+export default Value;

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

@@ -1,39 +1,46 @@
-var Node = require('./node'),
-    Variable = require('./variable'),
-    Ruleset = require('./ruleset'),
-    DetachedRuleset = require('./detached-ruleset'),
-    LessError = require('../less-error');
+import Node from './node';
+import Variable from './variable';
+import Ruleset from './ruleset';
+import DetachedRuleset from './detached-ruleset';
+import LessError from '../less-error';
 
-var VariableCall = function (variable, index, currentFileInfo) {
-    this.variable = variable;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.allowRoot = true;
-};
-VariableCall.prototype = new Node();
-VariableCall.prototype.type = 'VariableCall';
-VariableCall.prototype.eval = function (context) {
-    var rules, detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context),
-        error = new LessError({message: 'Could not evaluate variable call ' + this.variable});
+class VariableCall extends Node {
+    constructor(variable, index, currentFileInfo) {
+        super();
 
-    if (!detachedRuleset.ruleset) {
-        if (detachedRuleset.rules) {
-            rules = detachedRuleset;
-        }
-        else if (Array.isArray(detachedRuleset)) {
-            rules = new Ruleset('', detachedRuleset);
-        }
-        else if (Array.isArray(detachedRuleset.value)) {
-            rules = new Ruleset('', detachedRuleset.value);
+        this.variable = variable;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.allowRoot = true;
+    }
+
+    eval(context) {
+        let rules;
+        let detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context);
+        const error = new LessError({message: `Could not evaluate variable call ${this.variable}`});
+
+        if (!detachedRuleset.ruleset) {
+            if (detachedRuleset.rules) {
+                rules = detachedRuleset;
+            }
+            else if (Array.isArray(detachedRuleset)) {
+                rules = new Ruleset('', detachedRuleset);
+            }
+            else if (Array.isArray(detachedRuleset.value)) {
+                rules = new Ruleset('', detachedRuleset.value);
+            }
+            else {
+                throw error;
+            }
+            detachedRuleset = new DetachedRuleset(rules);
         }
-        else {
-            throw error;
+
+        if (detachedRuleset.ruleset) {
+            return detachedRuleset.callEval(context);
         }
-        detachedRuleset = new DetachedRuleset(rules);
-    }
-    if (detachedRuleset.ruleset) {
-        return detachedRuleset.callEval(context);
+        throw error;
     }
-    throw error;
-};
-module.exports = VariableCall;
+}
+
+VariableCall.prototype.type = 'VariableCall';
+export default VariableCall;

package/lib/less/tree/variable.js

@@ -1,60 +1,67 @@
-var Node = require('./node'),
-    Call = require('./call');
-
-var Variable = function (name, index, currentFileInfo) {
-    this.name = name;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-Variable.prototype = new Node();
-Variable.prototype.type = 'Variable';
-Variable.prototype.eval = function (context) {
-    var variable, name = this.name;
+import Node from './node';
+import Call from './call';
 
-    if (name.indexOf('@@') === 0) {
-        name = '@' + new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value;
-    }
+class Variable extends Node {
+    constructor(name, index, currentFileInfo) {
+        super();
 
-    if (this.evaluating) {
-        throw { type: 'Name',
-            message: 'Recursive variable definition for ' + name,
-            filename: this.fileInfo().filename,
-            index: this.getIndex() };
+        this.name = name;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
     }
 
-    this.evaluating = true;
+    eval(context) {
+        let variable;
+        let name = this.name;
 
-    variable = this.find(context.frames, function (frame) {
-        var v = frame.variable(name);
-        if (v) {
-            if (v.important) {
-                var importantScope = context.importantScope[context.importantScope.length - 1];
-                importantScope.important = v.important;
-            }
-            // If in calc, wrap vars in a function call to cascade evaluate args first
-            if (context.inCalc) {
-                return (new Call('_SELF', [v.value])).eval(context);
-            }
-            else {
-                return v.value.eval(context);
+        if (name.indexOf('@@') === 0) {
+            name = `@${new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value}`;
+        }
+
+        if (this.evaluating) {
+            throw { type: 'Name',
+                message: `Recursive variable definition for ${name}`,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+
+        this.evaluating = true;
+
+        variable = this.find(context.frames, frame => {
+            const v = frame.variable(name);
+            if (v) {
+                if (v.important) {
+                    const importantScope = context.importantScope[context.importantScope.length - 1];
+                    importantScope.important = v.important;
+                }
+                // If in calc, wrap vars in a function call to cascade evaluate args first
+                if (context.inCalc) {
+                    return (new Call('_SELF', [v.value])).eval(context);
+                }
+                else {
+                    return v.value.eval(context);
+                }
             }
+        });
+        if (variable) {
+            this.evaluating = false;
+            return variable;
+        } else {
+            throw { type: 'Name',
+                message: `variable ${name} is undefined`,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
         }
-    });
-    if (variable) {
-        this.evaluating = false;
-        return variable;
-    } else {
-        throw { type: 'Name',
-            message: 'variable ' + name + ' is undefined',
-            filename: this.fileInfo().filename,
-            index: this.getIndex() };
     }
-};
-Variable.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 = Variable;
+}
+
+Variable.prototype.type = 'Variable';
+export default Variable;

package/lib/less/utils.js

@@ -1,120 +1,122 @@
 /* jshint proto: true */
-var Constants = require('./constants');
-var clone = require('clone');
+import * as Constants from './constants';
+import CloneHelper from 'clone';
 
-var utils = {
-    getLocation: function(index, inputStream) {
-        var n = index + 1,
-            line = null,
-            column = -1;
+export function getLocation(index, inputStream) {
+    let n = index + 1;
+    let line = null;
+    let column = -1;
 
-        while (--n >= 0 && inputStream.charAt(n) !== '\n') {
-            column++;
-        }
+    while (--n >= 0 && inputStream.charAt(n) !== '\n') {
+        column++;
+    }
 
-        if (typeof index === 'number') {
-            line = (inputStream.slice(0, index).match(/\n/g) || '').length;
-        }
+    if (typeof index === 'number') {
+        line = (inputStream.slice(0, index).match(/\n/g) || '').length;
+    }
 
-        return {
-            line: line,
-            column: column
-        };
-    },
-    copyArray: function(arr) {
-        var i, length = arr.length,
-            copy = new Array(length);
-        
-        for (i = 0; i < length; i++) {
-            copy[i] = arr[i];
-        }
-        return copy;
-    },
-    clone: function (obj) {
-        var cloned = {};
-        for (var prop in obj) {
-            if (obj.hasOwnProperty(prop)) {
-                cloned[prop] = obj[prop];
-            }
-        }
-        return cloned;
-    },
-    copyOptions: function(obj1, obj2) {
-        if (obj2 && obj2._defaults) {
-            return obj2;
-        }
-        var opts = utils.defaults(obj1, obj2);
-        if (opts.strictMath) {
-            opts.math = Constants.Math.STRICT_LEGACY;
-        }
-        // Back compat with changed relativeUrls option
-        if (opts.relativeUrls) {
-            opts.rewriteUrls = Constants.RewriteUrls.ALL;
-        }
-        if (typeof opts.math === 'string') {
-            switch (opts.math.toLowerCase()) {
-                case 'always':
-                    opts.math = Constants.Math.ALWAYS;
-                    break;
-                case 'parens-division':
-                    opts.math = Constants.Math.PARENS_DIVISION;
-                    break;
-                case 'strict':
-                case 'parens':
-                    opts.math = Constants.Math.PARENS;
-                    break;
-                case 'strict-legacy':
-                    opts.math = Constants.Math.STRICT_LEGACY;
-            }
+    return {
+        line,
+        column
+    };
+}
+
+export function copyArray(arr) {
+    let i;
+    const length = arr.length;
+    const copy = new Array(length);
+
+    for (i = 0; i < length; i++) {
+        copy[i] = arr[i];
+    }
+    return copy;
+}
+
+export function clone(obj) {
+    const cloned = {};
+    for (const prop in obj) {
+        if (obj.hasOwnProperty(prop)) {
+            cloned[prop] = obj[prop];
         }
-        if (typeof opts.rewriteUrls === 'string') {
-            switch (opts.rewriteUrls.toLowerCase()) {
-                case 'off':
-                    opts.rewriteUrls = Constants.RewriteUrls.OFF;
-                    break;
-                case 'local':
-                    opts.rewriteUrls = Constants.RewriteUrls.LOCAL;
-                    break;
-                case 'all':
-                    opts.rewriteUrls = Constants.RewriteUrls.ALL;
-                    break;
-            }
+    }
+    return cloned;
+}
+
+export function defaults(obj1, obj2) {
+    let newObj = obj2 || {};
+    if (!obj2._defaults) {
+        newObj = {};
+        const defaults = CloneHelper(obj1);
+        newObj._defaults = defaults;
+        const cloned = obj2 ? CloneHelper(obj2) : {};
+        Object.assign(newObj, defaults, cloned);
+    }
+    return newObj;
+}
+
+export function copyOptions(obj1, obj2) {
+    if (obj2 && obj2._defaults) {
+        return obj2;
+    }
+    const opts = defaults(obj1, obj2);
+    if (opts.strictMath) {
+        opts.math = Constants.Math.STRICT_LEGACY;
+    }
+    // Back compat with changed relativeUrls option
+    if (opts.relativeUrls) {
+        opts.rewriteUrls = Constants.RewriteUrls.ALL;
+    }
+    if (typeof opts.math === 'string') {
+        switch (opts.math.toLowerCase()) {
+            case 'always':
+                opts.math = Constants.Math.ALWAYS;
+                break;
+            case 'parens-division':
+                opts.math = Constants.Math.PARENS_DIVISION;
+                break;
+            case 'strict':
+            case 'parens':
+                opts.math = Constants.Math.PARENS;
+                break;
+            case 'strict-legacy':
+                opts.math = Constants.Math.STRICT_LEGACY;
         }
-        return opts;
-    },
-    defaults: function(obj1, obj2) {
-        var newObj = obj2 || {};
-        if (!obj2._defaults) {
-            newObj = {};
-            var defaults = clone(obj1);
-            newObj._defaults = defaults;
-            var cloned = obj2 ? clone(obj2) : {};
-            Object.assign(newObj, defaults, cloned);
+    }
+    if (typeof opts.rewriteUrls === 'string') {
+        switch (opts.rewriteUrls.toLowerCase()) {
+            case 'off':
+                opts.rewriteUrls = Constants.RewriteUrls.OFF;
+                break;
+            case 'local':
+                opts.rewriteUrls = Constants.RewriteUrls.LOCAL;
+                break;
+            case 'all':
+                opts.rewriteUrls = Constants.RewriteUrls.ALL;
+                break;
         }
-        return newObj;
-    },
-    merge: function(obj1, obj2) {
-        for (var prop in obj2) {
-            if (obj2.hasOwnProperty(prop)) {
-                obj1[prop] = obj2[prop];
-            }
+    }
+    return opts;
+}
+
+export function merge(obj1, obj2) {
+    for (const prop in obj2) {
+        if (obj2.hasOwnProperty(prop)) {
+            obj1[prop] = obj2[prop];
         }
-        return obj1;
-    },
-    flattenArray: function(arr, result) {
-        result = result || [];
-        for (var i = 0, length = arr.length; i < length; i++) {
-            var value = arr[i];
-            if (Array.isArray(value)) {
-                utils.flattenArray(value, result);
-            } else {
-                if (value !== undefined) {
-                    result.push(value);
-                }
+    }
+    return obj1;
+}
+
+export function flattenArray(arr, result = []) {
+    for (let i = 0, length = arr.length; i < length; i++) {
+        const value = arr[i];
+        if (Array.isArray(value)) {
+            flattenArray(value, result);
+        } else {
+            if (value !== undefined) {
+                result.push(value);
             }
         }
-        return result;
     }
-};
-
-module.exports = utils;
+    return result;
+}