less 3.9.0 → 3.10.1

package/lib/less/source-map-output.js

@@ -1,143 +1,149 @@
-module.exports = function (environment) {
-
-    var SourceMapOutput = function (options) {
-        this._css = [];
-        this._rootNode = options.rootNode;
-        this._contentsMap = options.contentsMap;
-        this._contentsIgnoredCharsMap = options.contentsIgnoredCharsMap;
-        if (options.sourceMapFilename) {
-            this._sourceMapFilename = options.sourceMapFilename.replace(/\\/g, '/');
-        }
-        this._outputFilename = options.outputFilename;
-        this.sourceMapURL = options.sourceMapURL;
-        if (options.sourceMapBasepath) {
-            this._sourceMapBasepath = options.sourceMapBasepath.replace(/\\/g, '/');
-        }
-        if (options.sourceMapRootpath) {
-            this._sourceMapRootpath = options.sourceMapRootpath.replace(/\\/g, '/');
-            if (this._sourceMapRootpath.charAt(this._sourceMapRootpath.length - 1) !== '/') {
-                this._sourceMapRootpath += '/';
+export default environment => {
+    class SourceMapOutput {
+        constructor(options) {
+            this._css = [];
+            this._rootNode = options.rootNode;
+            this._contentsMap = options.contentsMap;
+            this._contentsIgnoredCharsMap = options.contentsIgnoredCharsMap;
+            if (options.sourceMapFilename) {
+                this._sourceMapFilename = options.sourceMapFilename.replace(/\\/g, '/');
+            }
+            this._outputFilename = options.outputFilename;
+            this.sourceMapURL = options.sourceMapURL;
+            if (options.sourceMapBasepath) {
+                this._sourceMapBasepath = options.sourceMapBasepath.replace(/\\/g, '/');
+            }
+            if (options.sourceMapRootpath) {
+                this._sourceMapRootpath = options.sourceMapRootpath.replace(/\\/g, '/');
+                if (this._sourceMapRootpath.charAt(this._sourceMapRootpath.length - 1) !== '/') {
+                    this._sourceMapRootpath += '/';
+                }
+            } else {
+                this._sourceMapRootpath = '';
             }
-        } else {
-            this._sourceMapRootpath = '';
+            this._outputSourceFiles = options.outputSourceFiles;
+            this._sourceMapGeneratorConstructor = environment.getSourceMapGenerator();
+
+            this._lineNumber = 0;
+            this._column = 0;
         }
-        this._outputSourceFiles = options.outputSourceFiles;
-        this._sourceMapGeneratorConstructor = environment.getSourceMapGenerator();
-
-        this._lineNumber = 0;
-        this._column = 0;
-    };
-
-    SourceMapOutput.prototype.removeBasepath = function(path) {
-        if (this._sourceMapBasepath && path.indexOf(this._sourceMapBasepath) === 0) {
-            path = path.substring(this._sourceMapBasepath.length);
-            if (path.charAt(0) === '\\' || path.charAt(0) === '/') {
-                path = path.substring(1);
+
+        removeBasepath(path) {
+            if (this._sourceMapBasepath && path.indexOf(this._sourceMapBasepath) === 0) {
+                path = path.substring(this._sourceMapBasepath.length);
+                if (path.charAt(0) === '\\' || path.charAt(0) === '/') {
+                    path = path.substring(1);
+                }
             }
+
+            return path;
         }
 
-        return path;
-    };
+        normalizeFilename(filename) {
+            filename = filename.replace(/\\/g, '/');
+            filename = this.removeBasepath(filename);
+            return (this._sourceMapRootpath || '') + filename;
+        }
 
-    SourceMapOutput.prototype.normalizeFilename = function(filename) {
-        filename = filename.replace(/\\/g, '/');
-        filename = this.removeBasepath(filename);
-        return (this._sourceMapRootpath || '') + filename;
-    };
+        add(chunk, fileInfo, index, mapLines) {
+            // ignore adding empty strings
+            if (!chunk) {
+                return;
+            }
 
-    SourceMapOutput.prototype.add = function(chunk, fileInfo, index, mapLines) {
+            let lines;
+            let sourceLines;
+            let columns;
+            let sourceColumns;
+            let i;
+
+            if (fileInfo && fileInfo.filename) {
+                let inputSource = this._contentsMap[fileInfo.filename];
+
+                // remove vars/banner added to the top of the file
+                if (this._contentsIgnoredCharsMap[fileInfo.filename]) {
+                    // adjust the index
+                    index -= this._contentsIgnoredCharsMap[fileInfo.filename];
+                    if (index < 0) { index = 0; }
+                    // adjust the source
+                    inputSource = inputSource.slice(this._contentsIgnoredCharsMap[fileInfo.filename]);
+                }
 
-        // ignore adding empty strings
-        if (!chunk) {
-            return;
-        }
+                // ignore empty content
+                if (inputSource === undefined) {
+                    return;
+                }
 
-        var lines,
-            sourceLines,
-            columns,
-            sourceColumns,
-            i;
-
-        if (fileInfo && fileInfo.filename) {
-            var inputSource = this._contentsMap[fileInfo.filename];
-
-            // remove vars/banner added to the top of the file
-            if (this._contentsIgnoredCharsMap[fileInfo.filename]) {
-                // adjust the index
-                index -= this._contentsIgnoredCharsMap[fileInfo.filename];
-                if (index < 0) { index = 0; }
-                // adjust the source
-                inputSource = inputSource.slice(this._contentsIgnoredCharsMap[fileInfo.filename]);
+                inputSource = inputSource.substring(0, index);
+                sourceLines = inputSource.split('\n');
+                sourceColumns = sourceLines[sourceLines.length - 1];
             }
-            inputSource = inputSource.substring(0, index);
-            sourceLines = inputSource.split('\n');
-            sourceColumns = sourceLines[sourceLines.length - 1];
-        }
 
-        lines = chunk.split('\n');
-        columns = lines[lines.length - 1];
+            lines = chunk.split('\n');
+            columns = lines[lines.length - 1];
 
-        if (fileInfo && fileInfo.filename) {
-            if (!mapLines) {
-                this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column},
-                    original: { line: sourceLines.length, column: sourceColumns.length},
-                    source: this.normalizeFilename(fileInfo.filename)});
-            } else {
-                for (i = 0; i < lines.length; i++) {
-                    this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0},
-                        original: { line: sourceLines.length + i, column: i === 0 ? sourceColumns.length : 0},
+            if (fileInfo && fileInfo.filename) {
+                if (!mapLines) {
+                    this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column},
+                        original: { line: sourceLines.length, column: sourceColumns.length},
                         source: this.normalizeFilename(fileInfo.filename)});
+                } else {
+                    for (i = 0; i < lines.length; i++) {
+                        this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0},
+                            original: { line: sourceLines.length + i, column: i === 0 ? sourceColumns.length : 0},
+                            source: this.normalizeFilename(fileInfo.filename)});
+                    }
                 }
             }
-        }
 
-        if (lines.length === 1) {
-            this._column += columns.length;
-        } else {
-            this._lineNumber += lines.length - 1;
-            this._column = columns.length;
-        }
-
-        this._css.push(chunk);
-    };
+            if (lines.length === 1) {
+                this._column += columns.length;
+            } else {
+                this._lineNumber += lines.length - 1;
+                this._column = columns.length;
+            }
 
-    SourceMapOutput.prototype.isEmpty = function() {
-        return this._css.length === 0;
-    };
+            this._css.push(chunk);
+        }
 
-    SourceMapOutput.prototype.toCSS = function(context) {
-        this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });
+        isEmpty() {
+            return this._css.length === 0;
+        }
 
-        if (this._outputSourceFiles) {
-            for (var filename in this._contentsMap) {
-                if (this._contentsMap.hasOwnProperty(filename)) {
-                    var source = this._contentsMap[filename];
-                    if (this._contentsIgnoredCharsMap[filename]) {
-                        source = source.slice(this._contentsIgnoredCharsMap[filename]);
+        toCSS(context) {
+            this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });
+
+            if (this._outputSourceFiles) {
+                for (const filename in this._contentsMap) {
+                    if (this._contentsMap.hasOwnProperty(filename)) {
+                        let source = this._contentsMap[filename];
+                        if (this._contentsIgnoredCharsMap[filename]) {
+                            source = source.slice(this._contentsIgnoredCharsMap[filename]);
+                        }
+                        this._sourceMapGenerator.setSourceContent(this.normalizeFilename(filename), source);
                     }
-                    this._sourceMapGenerator.setSourceContent(this.normalizeFilename(filename), source);
                 }
             }
-        }
 
-        this._rootNode.genCSS(context, this);
+            this._rootNode.genCSS(context, this);
 
-        if (this._css.length > 0) {
-            var sourceMapURL,
-                sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
+            if (this._css.length > 0) {
+                let sourceMapURL;
+                const sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
 
-            if (this.sourceMapURL) {
-                sourceMapURL = this.sourceMapURL;
-            } else if (this._sourceMapFilename) {
-                sourceMapURL = this._sourceMapFilename;
+                if (this.sourceMapURL) {
+                    sourceMapURL = this.sourceMapURL;
+                } else if (this._sourceMapFilename) {
+                    sourceMapURL = this._sourceMapFilename;
+                }
+                this.sourceMapURL = sourceMapURL;
+
+                this.sourceMap = sourceMapContent;
             }
-            this.sourceMapURL = sourceMapURL;
 
-            this.sourceMap = sourceMapContent;
+            return this._css.join('');
         }
-
-        return this._css.join('');
-    };
+    }
 
     return SourceMapOutput;
 };

package/lib/less/transform-tree.js

@@ -1,12 +1,11 @@
-var contexts = require('./contexts'),
-    visitor = require('./visitors'),
-    tree = require('./tree');
+import contexts from './contexts';
+import visitor from './visitors';
+import tree from './tree';
 
-module.exports = function(root, options) {
-    options = options || {};
-    var evaldRoot,
-        variables = options.variables,
-        evalEnv = new contexts.Eval(options);
+export default (root, options = {}) => {
+    let evaldRoot;
+    let variables = options.variables;
+    const evalEnv = new contexts.Eval(options);
 
     //
     // Allows setting variables with a hash, so:
@@ -22,8 +21,8 @@ module.exports = function(root, options) {
     //   )
     //
     if (typeof variables === 'object' && !Array.isArray(variables)) {
-        variables = Object.keys(variables).map(function (k) {
-            var value = variables[k];
+        variables = Object.keys(variables).map(k => {
+            let value = variables[k];
 
             if (!(value instanceof tree.Value)) {
                 if (!(value instanceof tree.Expression)) {
@@ -31,17 +30,21 @@ module.exports = function(root, options) {
                 }
                 value = new tree.Value([value]);
             }
-            return new tree.Declaration('@' + k, value, false, null, 0);
+            return new tree.Declaration(`@${k}`, value, false, null, 0);
         });
         evalEnv.frames = [new tree.Ruleset(null, variables)];
     }
 
-    var visitors = [
-            new visitor.JoinSelectorVisitor(),
-            new visitor.MarkVisibleSelectorsVisitor(true),
-            new visitor.ExtendVisitor(),
-            new visitor.ToCSSVisitor({compress: Boolean(options.compress)})
-        ], preEvalVisitors = [], v, visitorIterator;
+    const visitors = [
+        new visitor.JoinSelectorVisitor(),
+        new visitor.MarkVisibleSelectorsVisitor(true),
+        new visitor.ExtendVisitor(),
+        new visitor.ToCSSVisitor({compress: Boolean(options.compress)})
+    ];
+
+    const preEvalVisitors = [];
+    let v;
+    let visitorIterator;
 
     /**
      * first() / get() allows visitors to be added while visiting
@@ -72,7 +75,7 @@ module.exports = function(root, options) {
             }
         }
     }
-    
+
     evaldRoot = root.eval(evalEnv);
 
     for (var i = 0; i < visitors.length; i++) {

package/lib/less/tree/anonymous.js

@@ -1,29 +1,37 @@
-var Node = require('./node');
+import Node from './node';
 
-var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike, visibilityInfo) {
-    this.value = value;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.mapLines = mapLines;
-    this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
-    this.allowRoot = true;
-    this.copyVisibilityInfo(visibilityInfo);
-};
-Anonymous.prototype = new Node();
-Anonymous.prototype.type = 'Anonymous';
-Anonymous.prototype.eval = function () {
-    return new Anonymous(this.value, this._index, this._fileInfo, this.mapLines, this.rulesetLike, this.visibilityInfo());
-};
-Anonymous.prototype.compare = function (other) {
-    return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
-};
-Anonymous.prototype.isRulesetLike = function() {
-    return this.rulesetLike;
-};
-Anonymous.prototype.genCSS = function (context, output) {
-    this.nodeVisible = Boolean(this.value);
-    if (this.nodeVisible) {
-        output.add(this.value, this._fileInfo, this._index, this.mapLines);
+class Anonymous extends Node {
+    constructor(value, index, currentFileInfo, mapLines, rulesetLike, visibilityInfo) {
+        super();
+
+        this.value = value;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.mapLines = mapLines;
+        this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
+        this.allowRoot = true;
+        this.copyVisibilityInfo(visibilityInfo);
+    }
+
+    eval() {
+        return new Anonymous(this.value, this._index, this._fileInfo, this.mapLines, this.rulesetLike, this.visibilityInfo());
+    }
+
+    compare(other) {
+        return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
     }
-};
-module.exports = Anonymous;
+
+    isRulesetLike() {
+        return this.rulesetLike;
+    }
+
+    genCSS(context, output) {
+        this.nodeVisible = Boolean(this.value);
+        if (this.nodeVisible) {
+            output.add(this.value, this._fileInfo, this._index, this.mapLines);
+        }
+    }
+}
+
+Anonymous.prototype.type = 'Anonymous';
+export default Anonymous;

package/lib/less/tree/assignment.js

@@ -1,27 +1,33 @@
-var Node = require('./node');
+import Node from './node';
 
-var Assignment = function (key, val) {
-    this.key = key;
-    this.value = val;
-};
+class Assignment extends Node {
+    constructor(key, val) {
+        super();
 
-Assignment.prototype = new Node();
-Assignment.prototype.type = 'Assignment';
-Assignment.prototype.accept = function (visitor) {
-    this.value = visitor.visit(this.value);
-};
-Assignment.prototype.eval = function (context) {
-    if (this.value.eval) {
-        return new Assignment(this.key, this.value.eval(context));
+        this.key = key;
+        this.value = val;
+    }
+
+    accept(visitor) {
+        this.value = visitor.visit(this.value);
+    }
+
+    eval(context) {
+        if (this.value.eval) {
+            return new Assignment(this.key, this.value.eval(context));
+        }
+        return this;
     }
-    return this;
-};
-Assignment.prototype.genCSS = function (context, output) {
-    output.add(this.key + '=');
-    if (this.value.genCSS) {
-        this.value.genCSS(context, output);
-    } else {
-        output.add(this.value);
+
+    genCSS(context, output) {
+        output.add(`${this.key}=`);
+        if (this.value.genCSS) {
+            this.value.genCSS(context, output);
+        } else {
+            output.add(this.value);
+        }
     }
-};
-module.exports = Assignment;
+}
+
+Assignment.prototype.type = 'Assignment';
+export default Assignment;