less 3.9.0 → 3.10.1

package/lib/less/tree/selector.js

@@ -1,131 +1,146 @@
-var Node = require('./node'),
-    Element = require('./element'),
-    LessError = require('../less-error');
-
-var Selector = function (elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
-    this.extendList = extendList;
-    this.condition = condition;
-    this.evaldCondition = !condition;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.elements = this.getElements(elements);
-    this.mixinElements_ = undefined;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.setParent(this.elements, this);
-};
-Selector.prototype = new Node();
-Selector.prototype.type = 'Selector';
-Selector.prototype.accept = function (visitor) {
-    if (this.elements) {
-        this.elements = visitor.visitArray(this.elements);
+import Node from './node';
+import Element from './element';
+import LessError from '../less-error';
+
+class Selector extends Node {
+    constructor(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.extendList = extendList;
+        this.condition = condition;
+        this.evaldCondition = !condition;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.elements = this.getElements(elements);
+        this.mixinElements_ = undefined;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.elements, this);
     }
-    if (this.extendList) {
-        this.extendList = visitor.visitArray(this.extendList);
+
+    accept(visitor) {
+        if (this.elements) {
+            this.elements = visitor.visitArray(this.elements);
+        }
+        if (this.extendList) {
+            this.extendList = visitor.visitArray(this.extendList);
+        }
+        if (this.condition) {
+            this.condition = visitor.visit(this.condition);
+        }
     }
-    if (this.condition) {
-        this.condition = visitor.visit(this.condition);
+
+    createDerived(elements, extendList, evaldCondition) {
+        elements = this.getElements(elements);
+        const newSelector = new Selector(elements, extendList || this.extendList,
+            null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+        newSelector.evaldCondition = (evaldCondition != null) ? evaldCondition : this.evaldCondition;
+        newSelector.mediaEmpty = this.mediaEmpty;
+        return newSelector;
     }
-};
-Selector.prototype.createDerived = function(elements, extendList, evaldCondition) {
-    elements = this.getElements(elements);
-    var newSelector = new Selector(elements, extendList || this.extendList,
-        null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    newSelector.evaldCondition = (evaldCondition != null) ? evaldCondition : this.evaldCondition;
-    newSelector.mediaEmpty = this.mediaEmpty;
-    return newSelector;
-};
-Selector.prototype.getElements = function(els) {
-    if (!els) {
-        return [new Element('', '&', false, this._index, this._fileInfo)];
+
+    getElements(els) {
+        if (!els) {
+            return [new Element('', '&', false, this._index, this._fileInfo)];
+        }
+        if (typeof els === 'string') {
+            this.parse.parseNode(
+                els, 
+                ['selector'],
+                this._index, 
+                this._fileInfo, 
+                function(err, result) {
+                    if (err) {
+                        throw new LessError({
+                            index: err.index,
+                            message: err.message
+                        }, this.parse.imports, this._fileInfo.filename);
+                    }
+                    els = result[0].elements;
+                });
+        }
+        return els;
     }
-    if (typeof els === 'string') {
-        this.parse.parseNode(
-            els, 
-            ['selector'],
-            this._index, 
-            this._fileInfo, 
-            function(err, result) {
-                if (err) {
-                    throw new LessError({
-                        index: err.index,
-                        message: err.message
-                    }, this.parse.imports, this._fileInfo.filename);
+
+    createEmptySelectors() {
+        const el = new Element('', '&', false, this._index, this._fileInfo);
+        const sels = [new Selector([el], null, null, this._index, this._fileInfo)];
+        sels[0].mediaEmpty = true;
+        return sels;
+    }
+
+    match(other) {
+        const elements = this.elements;
+        const len = elements.length;
+        let olen;
+        let i;
+
+        other = other.mixinElements();
+        olen = other.length;
+        if (olen === 0 || len < olen) {
+            return 0;
+        } else {
+            for (i = 0; i < olen; i++) {
+                if (elements[i].value !== other[i]) {
+                    return 0;
                 }
-                els = result[0].elements;
-            });
+            }
+        }
+
+        return olen; // return number of matched elements
     }
-    return els;
-};
-Selector.prototype.createEmptySelectors = function() {
-    var el = new Element('', '&', false, this._index, this._fileInfo),
-        sels = [new Selector([el], null, null, this._index, this._fileInfo)];
-    sels[0].mediaEmpty = true;
-    return sels;
-};
-Selector.prototype.match = function (other) {
-    var elements = this.elements,
-        len = elements.length,
-        olen, i;
-
-    other = other.mixinElements();
-    olen = other.length;
-    if (olen === 0 || len < olen) {
-        return 0;
-    } else {
-        for (i = 0; i < olen; i++) {
-            if (elements[i].value !== other[i]) {
-                return 0;
+
+    mixinElements() {
+        if (this.mixinElements_) {
+            return this.mixinElements_;
+        }
+
+        let elements = this.elements.map( v => v.combinator.value + (v.value.value || v.value)).join('').match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
+
+        if (elements) {
+            if (elements[0] === '&') {
+                elements.shift();
             }
+        } else {
+            elements = [];
         }
+
+        return (this.mixinElements_ = elements);
     }
 
-    return olen; // return number of matched elements
-};
-Selector.prototype.mixinElements = function() {
-    if (this.mixinElements_) {
-        return this.mixinElements_;
+    isJustParentSelector() {
+        return !this.mediaEmpty &&
+            this.elements.length === 1 &&
+            this.elements[0].value === '&' &&
+            (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');
     }
 
-    var elements = this.elements.map( function(v) {
-        return v.combinator.value + (v.value.value || v.value);
-    }).join('').match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
+    eval(context) {
+        const evaldCondition = this.condition && this.condition.eval(context);
+        let elements = this.elements;
+        let extendList = this.extendList;
 
-    if (elements) {
-        if (elements[0] === '&') {
-            elements.shift();
-        }
-    } else {
-        elements = [];
+        elements = elements && elements.map(e => e.eval(context));
+        extendList = extendList && extendList.map(extend => extend.eval(context));
+
+        return this.createDerived(elements, extendList, evaldCondition);
     }
 
-    return (this.mixinElements_ = elements);
-};
-Selector.prototype.isJustParentSelector = function() {
-    return !this.mediaEmpty &&
-        this.elements.length === 1 &&
-        this.elements[0].value === '&' &&
-        (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');
-};
-Selector.prototype.eval = function (context) {
-    var evaldCondition = this.condition && this.condition.eval(context),
-        elements = this.elements, extendList = this.extendList;
-
-    elements = elements && elements.map(function (e) { return e.eval(context); });
-    extendList = extendList && extendList.map(function(extend) { return extend.eval(context); });
-
-    return this.createDerived(elements, extendList, evaldCondition);
-};
-Selector.prototype.genCSS = function (context, output) {
-    var i, element;
-    if ((!context || !context.firstSelector) && this.elements[0].combinator.value === '') {
-        output.add(' ', this.fileInfo(), this.getIndex());
+    genCSS(context, output) {
+        let i;
+        let element;
+        if ((!context || !context.firstSelector) && this.elements[0].combinator.value === '') {
+            output.add(' ', this.fileInfo(), this.getIndex());
+        }
+        for (i = 0; i < this.elements.length; i++) {
+            element = this.elements[i];
+            element.genCSS(context, output);
+        }
     }
-    for (i = 0; i < this.elements.length; i++) {
-        element = this.elements[i];
-        element.genCSS(context, output);
+
+    getIsOutput() {
+        return this.evaldCondition;
     }
-};
-Selector.prototype.getIsOutput = function() {
-    return this.evaldCondition;
-};
-module.exports = Selector;
+}
+
+Selector.prototype.type = 'Selector';
+export default Selector;

package/lib/less/tree/unicode-descriptor.js

@@ -1,9 +1,13 @@
-var Node = require('./node');
+import Node from './node';
+
+class UnicodeDescriptor extends Node {
+    constructor(value) {
+        super();
+
+        this.value = value;
+    }
+}
 
-var UnicodeDescriptor = function (value) {
-    this.value = value;
-};
-UnicodeDescriptor.prototype = new Node();
 UnicodeDescriptor.prototype.type = 'UnicodeDescriptor';
 
-module.exports = UnicodeDescriptor;
+export default UnicodeDescriptor;

package/lib/less/tree/unit.js

@@ -1,121 +1,141 @@
-var Node = require('./node'),
-    unitConversions = require('../data/unit-conversions'),
-    utils = require('../utils');
-
-var Unit = function (numerator, denominator, backupUnit) {
-    this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
-    this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
-    if (backupUnit) {
-        this.backupUnit = backupUnit;
-    } else if (numerator && numerator.length) {
-        this.backupUnit = numerator[0];
+import Node from './node';
+import unitConversions from '../data/unit-conversions';
+import * as utils from '../utils';
+
+class Unit extends Node {
+    constructor(numerator, denominator, backupUnit) {
+        super();
+
+        this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
+        this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
+        if (backupUnit) {
+            this.backupUnit = backupUnit;
+        } else if (numerator && numerator.length) {
+            this.backupUnit = numerator[0];
+        }
     }
-};
 
-Unit.prototype = new Node();
-Unit.prototype.type = 'Unit';
-Unit.prototype.clone = function () {
-    return new Unit(utils.copyArray(this.numerator), utils.copyArray(this.denominator), this.backupUnit);
-};
-Unit.prototype.genCSS = function (context, output) {
-    // Dimension checks the unit is singular and throws an error if in strict math mode.
-    var strictUnits = context && context.strictUnits;
-    if (this.numerator.length === 1) {
-        output.add(this.numerator[0]); // the ideal situation
-    } else if (!strictUnits && this.backupUnit) {
-        output.add(this.backupUnit);
-    } else if (!strictUnits && this.denominator.length) {
-        output.add(this.denominator[0]);
+    clone() {
+        return new Unit(utils.copyArray(this.numerator), utils.copyArray(this.denominator), this.backupUnit);
     }
-};
-Unit.prototype.toString = function () {
-    var i, returnStr = this.numerator.join('*');
-    for (i = 0; i < this.denominator.length; i++) {
-        returnStr += '/' + this.denominator[i];
+
+    genCSS(context, output) {
+        // Dimension checks the unit is singular and throws an error if in strict math mode.
+        const strictUnits = context && context.strictUnits;
+        if (this.numerator.length === 1) {
+            output.add(this.numerator[0]); // the ideal situation
+        } else if (!strictUnits && this.backupUnit) {
+            output.add(this.backupUnit);
+        } else if (!strictUnits && this.denominator.length) {
+            output.add(this.denominator[0]);
+        }
     }
-    return returnStr;
-};
-Unit.prototype.compare = function (other) {
-    return this.is(other.toString()) ? 0 : undefined;
-};
-Unit.prototype.is = function (unitString) {
-    return this.toString().toUpperCase() === unitString.toUpperCase();
-};
-Unit.prototype.isLength = function () {
-    return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS());
-};
-Unit.prototype.isEmpty = function () {
-    return this.numerator.length === 0 && this.denominator.length === 0;
-};
-Unit.prototype.isSingular = function() {
-    return this.numerator.length <= 1 && this.denominator.length === 0;
-};
-Unit.prototype.map = function(callback) {
-    var i;
-
-    for (i = 0; i < this.numerator.length; i++) {
-        this.numerator[i] = callback(this.numerator[i], false);
+
+    toString() {
+        let i;
+        let returnStr = this.numerator.join('*');
+        for (i = 0; i < this.denominator.length; i++) {
+            returnStr += `/${this.denominator[i]}`;
+        }
+        return returnStr;
     }
 
-    for (i = 0; i < this.denominator.length; i++) {
-        this.denominator[i] = callback(this.denominator[i], true);
+    compare(other) {
+        return this.is(other.toString()) ? 0 : undefined;
     }
-};
-Unit.prototype.usedUnits = function() {
-    var group, result = {}, mapUnit, groupName;
-
-    mapUnit = function (atomicUnit) {
-        /* jshint loopfunc:true */
-        if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
-            result[groupName] = atomicUnit;
-        }
 
-        return atomicUnit;
-    };
+    is(unitString) {
+        return this.toString().toUpperCase() === unitString.toUpperCase();
+    }
 
-    for (groupName in unitConversions) {
-        if (unitConversions.hasOwnProperty(groupName)) {
-            group = unitConversions[groupName];
+    isLength() {
+        return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS());
+    }
 
-            this.map(mapUnit);
-        }
+    isEmpty() {
+        return this.numerator.length === 0 && this.denominator.length === 0;
+    }
+
+    isSingular() {
+        return this.numerator.length <= 1 && this.denominator.length === 0;
     }
 
-    return result;
-};
-Unit.prototype.cancel = function () {
-    var counter = {}, atomicUnit, i;
+    map(callback) {
+        let i;
+
+        for (i = 0; i < this.numerator.length; i++) {
+            this.numerator[i] = callback(this.numerator[i], false);
+        }
 
-    for (i = 0; i < this.numerator.length; i++) {
-        atomicUnit = this.numerator[i];
-        counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
+        for (i = 0; i < this.denominator.length; i++) {
+            this.denominator[i] = callback(this.denominator[i], true);
+        }
     }
 
-    for (i = 0; i < this.denominator.length; i++) {
-        atomicUnit = this.denominator[i];
-        counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
+    usedUnits() {
+        let group;
+        const result = {};
+        let mapUnit;
+        let groupName;
+
+        mapUnit = atomicUnit => {
+            /* jshint loopfunc:true */
+            if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
+                result[groupName] = atomicUnit;
+            }
+
+            return atomicUnit;
+        };
+
+        for (groupName in unitConversions) {
+            if (unitConversions.hasOwnProperty(groupName)) {
+                group = unitConversions[groupName];
+
+                this.map(mapUnit);
+            }
+        }
+
+        return result;
     }
 
-    this.numerator = [];
-    this.denominator = [];
+    cancel() {
+        const counter = {};
+        let atomicUnit;
+        let i;
 
-    for (atomicUnit in counter) {
-        if (counter.hasOwnProperty(atomicUnit)) {
-            var count = counter[atomicUnit];
+        for (i = 0; i < this.numerator.length; i++) {
+            atomicUnit = this.numerator[i];
+            counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
+        }
 
-            if (count > 0) {
-                for (i = 0; i < count; i++) {
-                    this.numerator.push(atomicUnit);
-                }
-            } else if (count < 0) {
-                for (i = 0; i < -count; i++) {
-                    this.denominator.push(atomicUnit);
+        for (i = 0; i < this.denominator.length; i++) {
+            atomicUnit = this.denominator[i];
+            counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
+        }
+
+        this.numerator = [];
+        this.denominator = [];
+
+        for (atomicUnit in counter) {
+            if (counter.hasOwnProperty(atomicUnit)) {
+                const count = counter[atomicUnit];
+
+                if (count > 0) {
+                    for (i = 0; i < count; i++) {
+                        this.numerator.push(atomicUnit);
+                    }
+                } else if (count < 0) {
+                    for (i = 0; i < -count; i++) {
+                        this.denominator.push(atomicUnit);
+                    }
                 }
             }
         }
+
+        this.numerator.sort();
+        this.denominator.sort();
     }
+}
 
-    this.numerator.sort();
-    this.denominator.sort();
-};
-module.exports = Unit;
+Unit.prototype.type = 'Unit';
+export default Unit;

package/lib/less/tree/url.js

@@ -1,58 +1,65 @@
-var Node = require('./node');
-
-var URL = function (val, index, currentFileInfo, isEvald) {
-    this.value = val;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.isEvald = isEvald;
-};
-URL.prototype = new Node();
-URL.prototype.type = 'Url';
-URL.prototype.accept = function (visitor) {
-    this.value = visitor.visit(this.value);
-};
-URL.prototype.genCSS = function (context, output) {
-    output.add('url(');
-    this.value.genCSS(context, output);
-    output.add(')');
-};
-URL.prototype.eval = function (context) {
-    var val = this.value.eval(context),
-        rootpath;
-
-    if (!this.isEvald) {
-        // Add the rootpath if the URL requires a rewrite
-        rootpath = this.fileInfo() && this.fileInfo().rootpath;
-        if (typeof rootpath === 'string' &&
-            typeof val.value === 'string' &&
-            context.pathRequiresRewrite(val.value)) {
-            if (!val.quote) {
-                rootpath = escapePath(rootpath);
+import Node from './node';
+
+class URL extends Node {
+    constructor(val, index, currentFileInfo, isEvald) {
+        super();
+
+        this.value = val;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.isEvald = isEvald;
+    }
+
+    accept(visitor) {
+        this.value = visitor.visit(this.value);
+    }
+
+    genCSS(context, output) {
+        output.add('url(');
+        this.value.genCSS(context, output);
+        output.add(')');
+    }
+
+    eval(context) {
+        const val = this.value.eval(context);
+        let rootpath;
+
+        if (!this.isEvald) {
+            // Add the rootpath if the URL requires a rewrite
+            rootpath = this.fileInfo() && this.fileInfo().rootpath;
+            if (typeof rootpath === 'string' &&
+                typeof val.value === 'string' &&
+                context.pathRequiresRewrite(val.value)) {
+                if (!val.quote) {
+                    rootpath = escapePath(rootpath);
+                }
+                val.value = context.rewritePath(val.value, rootpath);
+            } else {
+                val.value = context.normalizePath(val.value);
             }
-            val.value = context.rewritePath(val.value, rootpath);
-        } else {
-            val.value = context.normalizePath(val.value);
-        }
 
-        // Add url args if enabled
-        if (context.urlArgs) {
-            if (!val.value.match(/^\s*data:/)) {
-                var delimiter = val.value.indexOf('?') === -1 ? '?' : '&';
-                var urlArgs = delimiter + context.urlArgs;
-                if (val.value.indexOf('#') !== -1) {
-                    val.value = val.value.replace('#', urlArgs + '#');
-                } else {
-                    val.value += urlArgs;
+            // Add url args if enabled
+            if (context.urlArgs) {
+                if (!val.value.match(/^\s*data:/)) {
+                    const delimiter = val.value.indexOf('?') === -1 ? '?' : '&';
+                    const urlArgs = delimiter + context.urlArgs;
+                    if (val.value.indexOf('#') !== -1) {
+                        val.value = val.value.replace('#', `${urlArgs}#`);
+                    } else {
+                        val.value += urlArgs;
+                    }
                 }
             }
         }
+
+        return new URL(val, this.getIndex(), this.fileInfo(), true);
     }
+}
 
-    return new URL(val, this.getIndex(), this.fileInfo(), true);
-};
+URL.prototype.type = 'Url';
 
 function escapePath(path) {
-    return path.replace(/[\(\)'"\s]/g, function(match) { return '\\' + match; });
+    return path.replace(/[\(\)'"\s]/g, match => `\\${match}`);
 }
 
-module.exports = URL;
+export default URL;