less 3.9.0 → 3.10.1

package/lib/less/tree/declaration.js

@@ -1,102 +1,115 @@
-var Node = require('./node'),
-    Value = require('./value'),
-    Keyword = require('./keyword'),
-    Anonymous = require('./anonymous'),
-    MATH = require('../constants').Math;
+import Node from './node';
+import Value from './value';
+import Keyword from './keyword';
+import Anonymous from './anonymous';
+import * as Constants from '../constants';
+const MATH = Constants.Math;
 
-var Declaration = function (name, value, important, merge, index, currentFileInfo, inline, variable) {
-    this.name = name;
-    this.value = (value instanceof Node) ? value : new Value([value ? new Anonymous(value) : null]);
-    this.important = important ? ' ' + important.trim() : '';
-    this.merge = merge;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.inline = inline || false;
-    this.variable = (variable !== undefined) ? variable
-        : (name.charAt && (name.charAt(0) === '@'));
-    this.allowRoot = true;
-    this.setParent(this.value, this);
-};
 
-function evalName(context, name) {
-    var value = '', i, n = name.length,
-        output = {add: function (s) {value += s;}};
-    for (i = 0; i < n; i++) {
-        name[i].eval(context).genCSS(context, output);
-    }
-    return value;
-}
+class Declaration extends Node {
+    constructor(name, value, important, merge, index, currentFileInfo, inline, variable) {
+        super();
 
-Declaration.prototype = new Node();
-Declaration.prototype.type = 'Declaration';
-Declaration.prototype.genCSS = function (context, output) {
-    output.add(this.name + (context.compress ? ':' : ': '), this.fileInfo(), this.getIndex());
-    try {
-        this.value.genCSS(context, output);
-    }
-    catch (e) {
-        e.index = this._index;
-        e.filename = this._fileInfo.filename;
-        throw e;
-    }
-    output.add(this.important + ((this.inline || (context.lastRule && context.compress)) ? '' : ';'), this._fileInfo, this._index);
-};
-Declaration.prototype.eval = function (context) {
-    var mathBypass = false, prevMath, name = this.name, evaldValue, variable = this.variable;
-    if (typeof name !== 'string') {
-        // expand 'primitive' name directly to get
-        // things faster (~10% for benchmark.less):
-        name = (name.length === 1) && (name[0] instanceof Keyword) ?
-                name[0].value : evalName(context, name);
-        variable = false; // never treat expanded interpolation as new variable name
+        this.name = name;
+        this.value = (value instanceof Node) ? value : new Value([value ? new Anonymous(value) : null]);
+        this.important = important ? ` ${important.trim()}` : '';
+        this.merge = merge;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.inline = inline || false;
+        this.variable = (variable !== undefined) ? variable
+            : (name.charAt && (name.charAt(0) === '@'));
+        this.allowRoot = true;
+        this.setParent(this.value, this);
     }
 
-    // @todo remove when parens-division is default
-    if (name === 'font' && context.math === MATH.ALWAYS) {
-        mathBypass = true;
-        prevMath = context.math;
-        context.math = MATH.PARENS_DIVISION;
+    genCSS(context, output) {
+        output.add(this.name + (context.compress ? ':' : ': '), this.fileInfo(), this.getIndex());
+        try {
+            this.value.genCSS(context, output);
+        }
+        catch (e) {
+            e.index = this._index;
+            e.filename = this._fileInfo.filename;
+            throw e;
+        }
+        output.add(this.important + ((this.inline || (context.lastRule && context.compress)) ? '' : ';'), this._fileInfo, this._index);
     }
-    try {
-        context.importantScope.push({});
-        evaldValue = this.value.eval(context);
 
-        if (!this.variable && evaldValue.type === 'DetachedRuleset') {
-            throw { message: 'Rulesets cannot be evaluated on a property.',
-                index: this.getIndex(), filename: this.fileInfo().filename };
+    eval(context) {
+        let mathBypass = false;
+        let prevMath;
+        let name = this.name;
+        let evaldValue;
+        let variable = this.variable;
+        if (typeof name !== 'string') {
+            // expand 'primitive' name directly to get
+            // things faster (~10% for benchmark.less):
+            name = (name.length === 1) && (name[0] instanceof Keyword) ?
+                name[0].value : evalName(context, name);
+            variable = false; // never treat expanded interpolation as new variable name
         }
-        var important = this.important,
-            importantResult = context.importantScope.pop();
-        if (!important && importantResult.important) {
-            important = importantResult.important;
+
+        // @todo remove when parens-division is default
+        if (name === 'font' && context.math === MATH.ALWAYS) {
+            mathBypass = true;
+            prevMath = context.math;
+            context.math = MATH.PARENS_DIVISION;
         }
+        try {
+            context.importantScope.push({});
+            evaldValue = this.value.eval(context);
 
-        return new Declaration(name,
-                          evaldValue,
-                          important,
-                          this.merge,
-                          this.getIndex(), this.fileInfo(), this.inline,
-                              variable);
-    }
-    catch (e) {
-        if (typeof e.index !== 'number') {
-            e.index = this.getIndex();
-            e.filename = this.fileInfo().filename;
+            if (!this.variable && evaldValue.type === 'DetachedRuleset') {
+                throw { message: 'Rulesets cannot be evaluated on a property.',
+                    index: this.getIndex(), filename: this.fileInfo().filename };
+            }
+            let important = this.important;
+            const importantResult = context.importantScope.pop();
+            if (!important && importantResult.important) {
+                important = importantResult.important;
+            }
+
+            return new Declaration(name,
+                evaldValue,
+                important,
+                this.merge,
+                this.getIndex(), this.fileInfo(), this.inline,
+                variable);
         }
-        throw e;
-    }
-    finally {
-        if (mathBypass) {
-            context.math = prevMath;
+        catch (e) {
+            if (typeof e.index !== 'number') {
+                e.index = this.getIndex();
+                e.filename = this.fileInfo().filename;
+            }
+            throw e;
         }
+        finally {
+            if (mathBypass) {
+                context.math = prevMath;
+            }
+        }
+    }
+
+    makeImportant() {
+        return new Declaration(this.name,
+            this.value,
+            '!important',
+            this.merge,
+            this.getIndex(), this.fileInfo(), this.inline);
+    }
+}
+
+function evalName(context, name) {
+    let value = '';
+    let i;
+    const n = name.length;
+    const output = {add: function (s) {value += s;}};
+    for (i = 0; i < n; i++) {
+        name[i].eval(context).genCSS(context, output);
     }
-};
-Declaration.prototype.makeImportant = function () {
-    return new Declaration(this.name,
-                          this.value,
-                          '!important',
-                          this.merge,
-                          this.getIndex(), this.fileInfo(), this.inline);
-};
+    return value;
+}
 
-module.exports = Declaration;
+Declaration.prototype.type = 'Declaration';
+export default Declaration;

package/lib/less/tree/detached-ruleset.js

@@ -1,23 +1,30 @@
-var Node = require('./node'),
-    contexts = require('../contexts'),
-    utils = require('../utils');
+import Node from './node';
+import contexts from '../contexts';
+import * as utils from '../utils';
+
+class DetachedRuleset extends Node {
+    constructor(ruleset, frames) {
+        super();
+
+        this.ruleset = ruleset;
+        this.frames = frames;
+        this.setParent(this.ruleset, this);
+    }
+
+    accept(visitor) {
+        this.ruleset = visitor.visit(this.ruleset);
+    }
+
+    eval(context) {
+        const frames = this.frames || utils.copyArray(context.frames);
+        return new DetachedRuleset(this.ruleset, frames);
+    }
+
+    callEval(context) {
+        return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
+    }
+}
 
-var DetachedRuleset = function (ruleset, frames) {
-    this.ruleset = ruleset;
-    this.frames = frames;
-    this.setParent(this.ruleset, this);
-};
-DetachedRuleset.prototype = new Node();
 DetachedRuleset.prototype.type = 'DetachedRuleset';
 DetachedRuleset.prototype.evalFirst = true;
-DetachedRuleset.prototype.accept = function (visitor) {
-    this.ruleset = visitor.visit(this.ruleset);
-};
-DetachedRuleset.prototype.eval = function (context) {
-    var frames = this.frames || utils.copyArray(context.frames);
-    return new DetachedRuleset(this.ruleset, frames);
-};
-DetachedRuleset.prototype.callEval = function (context) {
-    return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
-};
-module.exports = DetachedRuleset;
+export default DetachedRuleset;

package/lib/less/tree/dimension.js

@@ -1,161 +1,179 @@
-var Node = require('./node'),
-    unitConversions = require('../data/unit-conversions'),
-    Unit = require('./unit'),
-    Color = require('./color');
+import Node from './node';
+import unitConversions from '../data/unit-conversions';
+import Unit from './unit';
+import Color from './color';
 
 //
 // A number with a unit
 //
-var Dimension = function (value, unit) {
-    this.value = parseFloat(value);
-    if (isNaN(this.value)) {
-        throw new Error('Dimension is not a number.');
+class Dimension extends Node {
+    constructor(value, unit) {
+        super();
+
+        this.value = parseFloat(value);
+        if (isNaN(this.value)) {
+            throw new Error('Dimension is not a number.');
+        }
+        this.unit = (unit && unit instanceof Unit) ? unit :
+            new Unit(unit ? [unit] : undefined);
+        this.setParent(this.unit, this);
     }
-    this.unit = (unit && unit instanceof Unit) ? unit :
-      new Unit(unit ? [unit] : undefined);
-    this.setParent(this.unit, this);
-};
 
-Dimension.prototype = new Node();
-Dimension.prototype.type = 'Dimension';
-Dimension.prototype.accept = function (visitor) {
-    this.unit = visitor.visit(this.unit);
-};
-Dimension.prototype.eval = function (context) {
-    return this;
-};
-Dimension.prototype.toColor = function () {
-    return new Color([this.value, this.value, this.value]);
-};
-Dimension.prototype.genCSS = function (context, output) {
-    if ((context && context.strictUnits) && !this.unit.isSingular()) {
-        throw new Error('Multiple units in dimension. Correct the units or use the unit function. Bad unit: ' + this.unit.toString());
+    accept(visitor) {
+        this.unit = visitor.visit(this.unit);
     }
 
-    var value = this.fround(context, this.value),
-        strValue = String(value);
+    eval(context) {
+        return this;
+    }
 
-    if (value !== 0 && value < 0.000001 && value > -0.000001) {
-        // would be output 1e-6 etc.
-        strValue = value.toFixed(20).replace(/0+$/, '');
+    toColor() {
+        return new Color([this.value, this.value, this.value]);
     }
 
-    if (context && context.compress) {
-        // Zero values doesn't need a unit
-        if (value === 0 && this.unit.isLength()) {
-            output.add(strValue);
-            return;
+    genCSS(context, output) {
+        if ((context && context.strictUnits) && !this.unit.isSingular()) {
+            throw new Error(`Multiple units in dimension. Correct the units or use the unit function. Bad unit: ${this.unit.toString()}`);
         }
 
-        // Float values doesn't need a leading zero
-        if (value > 0 && value < 1) {
-            strValue = (strValue).substr(1);
+        const value = this.fround(context, this.value);
+        let strValue = String(value);
+
+        if (value !== 0 && value < 0.000001 && value > -0.000001) {
+            // would be output 1e-6 etc.
+            strValue = value.toFixed(20).replace(/0+$/, '');
         }
-    }
 
-    output.add(strValue);
-    this.unit.genCSS(context, output);
-};
-
-// In an operation between two Dimensions,
-// we default to the first Dimension's unit,
-// so `1px + 2` will yield `3px`.
-Dimension.prototype.operate = function (context, op, other) {
-    /* jshint noempty:false */
-    var value = this._operate(context, op, this.value, other.value),
-        unit = this.unit.clone();
-
-    if (op === '+' || op === '-') {
-        if (unit.numerator.length === 0 && unit.denominator.length === 0) {
-            unit = other.unit.clone();
-            if (this.unit.backupUnit) {
-                unit.backupUnit = this.unit.backupUnit;
+        if (context && context.compress) {
+            // Zero values doesn't need a unit
+            if (value === 0 && this.unit.isLength()) {
+                output.add(strValue);
+                return;
             }
-        } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
-            // do nothing
-        } else {
-            other = other.convertTo(this.unit.usedUnits());
 
-            if (context.strictUnits && other.unit.toString() !== unit.toString()) {
-                throw new Error('Incompatible units. Change the units or use the unit function. Bad units: \'' + unit.toString() +
-                    '\' and \'' + other.unit.toString() + '\'.');
+            // Float values doesn't need a leading zero
+            if (value > 0 && value < 1) {
+                strValue = (strValue).substr(1);
             }
-
-            value = this._operate(context, op, this.value, other.value);
         }
-    } else if (op === '*') {
-        unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
-        unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
-        unit.cancel();
-    } else if (op === '/') {
-        unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
-        unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
-        unit.cancel();
+
+        output.add(strValue);
+        this.unit.genCSS(context, output);
     }
-    return new Dimension(value, unit);
-};
-Dimension.prototype.compare = function (other) {
-    var a, b;
 
-    if (!(other instanceof Dimension)) {
-        return undefined;
+    // In an operation between two Dimensions,
+    // we default to the first Dimension's unit,
+    // so `1px + 2` will yield `3px`.
+    operate(context, op, other) {
+        /* jshint noempty:false */
+        let value = this._operate(context, op, this.value, other.value);
+
+        let unit = this.unit.clone();
+
+        if (op === '+' || op === '-') {
+            if (unit.numerator.length === 0 && unit.denominator.length === 0) {
+                unit = other.unit.clone();
+                if (this.unit.backupUnit) {
+                    unit.backupUnit = this.unit.backupUnit;
+                }
+            } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
+                // do nothing
+            } else {
+                other = other.convertTo(this.unit.usedUnits());
+
+                if (context.strictUnits && other.unit.toString() !== unit.toString()) {
+                    throw new Error(`Incompatible units. Change the units or use the unit function. ` + 
+                        `Bad units: '${unit.toString()}' and '${other.unit.toString()}'.`);
+                }
+
+                value = this._operate(context, op, this.value, other.value);
+            }
+        } else if (op === '*') {
+            unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
+            unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
+            unit.cancel();
+        } else if (op === '/') {
+            unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
+            unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
+            unit.cancel();
+        }
+        return new Dimension(value, unit);
     }
 
-    if (this.unit.isEmpty() || other.unit.isEmpty()) {
-        a = this;
-        b = other;
-    } else {
-        a = this.unify();
-        b = other.unify();
-        if (a.unit.compare(b.unit) !== 0) {
+    compare(other) {
+        let a;
+        let b;
+
+        if (!(other instanceof Dimension)) {
             return undefined;
         }
-    }
 
-    return Node.numericCompare(a.value, b.value);
-};
-Dimension.prototype.unify = function () {
-    return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
-};
-Dimension.prototype.convertTo = function (conversions) {
-    var value = this.value, unit = this.unit.clone(),
-        i, groupName, group, targetUnit, derivedConversions = {}, applyUnit;
-
-    if (typeof conversions === 'string') {
-        for (i in unitConversions) {
-            if (unitConversions[i].hasOwnProperty(conversions)) {
-                derivedConversions = {};
-                derivedConversions[i] = conversions;
+        if (this.unit.isEmpty() || other.unit.isEmpty()) {
+            a = this;
+            b = other;
+        } else {
+            a = this.unify();
+            b = other.unify();
+            if (a.unit.compare(b.unit) !== 0) {
+                return undefined;
             }
         }
-        conversions = derivedConversions;
+
+        return Node.numericCompare(a.value, b.value);
+    }
+
+    unify() {
+        return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
     }
-    applyUnit = function (atomicUnit, denominator) {
-        /* jshint loopfunc:true */
-        if (group.hasOwnProperty(atomicUnit)) {
-            if (denominator) {
-                value = value / (group[atomicUnit] / group[targetUnit]);
-            } else {
-                value = value * (group[atomicUnit] / group[targetUnit]);
-            }
 
-            return targetUnit;
+    convertTo(conversions) {
+        let value = this.value;
+        const unit = this.unit.clone();
+        let i;
+        let groupName;
+        let group;
+        let targetUnit;
+        let derivedConversions = {};
+        let applyUnit;
+
+        if (typeof conversions === 'string') {
+            for (i in unitConversions) {
+                if (unitConversions[i].hasOwnProperty(conversions)) {
+                    derivedConversions = {};
+                    derivedConversions[i] = conversions;
+                }
+            }
+            conversions = derivedConversions;
         }
+        applyUnit = (atomicUnit, denominator) => {
+            /* jshint loopfunc:true */
+            if (group.hasOwnProperty(atomicUnit)) {
+                if (denominator) {
+                    value = value / (group[atomicUnit] / group[targetUnit]);
+                } else {
+                    value = value * (group[atomicUnit] / group[targetUnit]);
+                }
+
+                return targetUnit;
+            }
 
-        return atomicUnit;
-    };
+            return atomicUnit;
+        };
 
-    for (groupName in conversions) {
-        if (conversions.hasOwnProperty(groupName)) {
-            targetUnit = conversions[groupName];
-            group = unitConversions[groupName];
+        for (groupName in conversions) {
+            if (conversions.hasOwnProperty(groupName)) {
+                targetUnit = conversions[groupName];
+                group = unitConversions[groupName];
 
-            unit.map(applyUnit);
+                unit.map(applyUnit);
+            }
         }
-    }
 
-    unit.cancel();
+        unit.cancel();
+
+        return new Dimension(value, unit);
+    }
+}
 
-    return new Dimension(value, unit);
-};
-module.exports = Dimension;
+Dimension.prototype.type = 'Dimension';
+export default Dimension;