less 3.9.0 → 3.10.1

package/lib/less/parse-tree.js

@@ -1,60 +1,66 @@
-var LessError = require('./less-error'),
-    transformTree = require('./transform-tree'),
-    logger = require('./logger');
-
-module.exports = function(SourceMapBuilder) {
-    var ParseTree = function(root, imports) {
-        this.root = root;
-        this.imports = imports;
-    };
-
-    ParseTree.prototype.toCSS = function(options) {
-        var evaldRoot, result = {}, sourceMapBuilder;
-        try {
-            evaldRoot = transformTree(this.root, options);
-        } catch (e) {
-            throw new LessError(e, this.imports);
+import LessError from './less-error';
+import transformTree from './transform-tree';
+import logger from './logger';
+
+export default SourceMapBuilder => {
+    class ParseTree {
+        constructor(root, imports) {
+            this.root = root;
+            this.imports = imports;
         }
 
-        try {
-            var compress = Boolean(options.compress);
-            if (compress) {
-                logger.warn('The compress option has been deprecated. We recommend you use a dedicated css minifier, for instance see less-plugin-clean-css.');
+        toCSS(options) {
+            let evaldRoot;
+            const result = {};
+            let sourceMapBuilder;
+            try {
+                evaldRoot = transformTree(this.root, options);
+            } catch (e) {
+                throw new LessError(e, this.imports);
             }
 
-            var toCSSOptions = {
-                compress: compress,
-                dumpLineNumbers: options.dumpLineNumbers,
-                strictUnits: Boolean(options.strictUnits),
-                numPrecision: 8};
+            try {
+                const compress = Boolean(options.compress);
+                if (compress) {
+                    logger.warn('The compress option has been deprecated. ' + 
+                        'We recommend you use a dedicated css minifier, for instance see less-plugin-clean-css.');
+                }
 
-            if (options.sourceMap) {
-                sourceMapBuilder = new SourceMapBuilder(options.sourceMap);
-                result.css = sourceMapBuilder.toCSS(evaldRoot, toCSSOptions, this.imports);
-            } else {
-                result.css = evaldRoot.toCSS(toCSSOptions);
+                const toCSSOptions = {
+                    compress,
+                    dumpLineNumbers: options.dumpLineNumbers,
+                    strictUnits: Boolean(options.strictUnits),
+                    numPrecision: 8};
+
+                if (options.sourceMap) {
+                    sourceMapBuilder = new SourceMapBuilder(options.sourceMap);
+                    result.css = sourceMapBuilder.toCSS(evaldRoot, toCSSOptions, this.imports);
+                } else {
+                    result.css = evaldRoot.toCSS(toCSSOptions);
+                }
+            } catch (e) {
+                throw new LessError(e, this.imports);
             }
-        } catch (e) {
-            throw new LessError(e, this.imports);
-        }
 
-        if (options.pluginManager) {
-            var postProcessors = options.pluginManager.getPostProcessors();
-            for (var i = 0; i < postProcessors.length; i++) {
-                result.css = postProcessors[i].process(result.css, { sourceMap: sourceMapBuilder, options: options, imports: this.imports });
+            if (options.pluginManager) {
+                const postProcessors = options.pluginManager.getPostProcessors();
+                for (let i = 0; i < postProcessors.length; i++) {
+                    result.css = postProcessors[i].process(result.css, { sourceMap: sourceMapBuilder, options, imports: this.imports });
+                }
+            }
+            if (options.sourceMap) {
+                result.map = sourceMapBuilder.getExternalSourceMap();
             }
-        }
-        if (options.sourceMap) {
-            result.map = sourceMapBuilder.getExternalSourceMap();
-        }
 
-        result.imports = [];
-        for (var file in this.imports.files) {
-            if (this.imports.files.hasOwnProperty(file) && file !== this.imports.rootFilename) {
-                result.imports.push(file);
+            result.imports = [];
+            for (const file in this.imports.files) {
+                if (this.imports.files.hasOwnProperty(file) && file !== this.imports.rootFilename) {
+                    result.imports.push(file);
+                }
             }
+            return result;
         }
-        return result;
-    };
+    }
+
     return ParseTree;
 };

package/lib/less/parse.js

@@ -1,12 +1,12 @@
-var PromiseConstructor,
-    contexts = require('./contexts'),
-    Parser = require('./parser/parser'),
-    PluginManager = require('./plugin-manager'),
-    LessError = require('./less-error'),
-    utils = require('./utils');
+let PromiseConstructor;
+import contexts from './contexts';
+import Parser from './parser/parser';
+import PluginManager from './plugin-manager';
+import LessError from './less-error';
+import * as utils from './utils';
 
-module.exports = function(environment, ParseTree, ImportManager) {
-    var parse = function (input, options, callback) {
+export default (environment, ParseTree, ImportManager) => {
+    const parse = function (input, options, callback) {
 
         if (typeof options === 'function') {
             callback = options;
@@ -17,12 +17,9 @@ module.exports = function(environment, ParseTree, ImportManager) {
         }
 
         if (!callback) {
-            if (!PromiseConstructor) {
-                PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise;
-            }
-            var self = this;
-            return new PromiseConstructor(function (resolve, reject) {
-                parse.call(self, input, options, function(err, output) {
+            const self = this;
+            return new Promise((resolve, reject) => {
+                parse.call(self, input, options, (err, output) => {
                     if (err) {
                         reject(err);
                     } else {
@@ -31,9 +28,9 @@ module.exports = function(environment, ParseTree, ImportManager) {
                 });
             });
         } else {
-            var context,
-                rootFileInfo,
-                pluginManager = new PluginManager(this, !options.reUsePluginManager);
+            let context;
+            let rootFileInfo;
+            const pluginManager = new PluginManager(this, !options.reUsePluginManager);
 
             options.pluginManager = pluginManager;
 
@@ -42,14 +39,14 @@ module.exports = function(environment, ParseTree, ImportManager) {
             if (options.rootFileInfo) {
                 rootFileInfo = options.rootFileInfo;
             } else {
-                var filename = options.filename || 'input';
-                var entryPath = filename.replace(/[^\/\\]*$/, '');
+                const filename = options.filename || 'input';
+                const entryPath = filename.replace(/[^\/\\]*$/, '');
                 rootFileInfo = {
-                    filename: filename,
+                    filename,
                     rewriteUrls: context.rewriteUrls,
                     rootpath: context.rootpath || '',
                     currentDirectory: entryPath,
-                    entryPath: entryPath,
+                    entryPath,
                     rootFilename: filename
                 };
                 // add in a missing trailing slash
@@ -58,15 +55,16 @@ module.exports = function(environment, ParseTree, ImportManager) {
                 }
             }
 
-            var imports = new ImportManager(this, context, rootFileInfo);
+            const imports = new ImportManager(this, context, rootFileInfo);
             this.importManager = imports;
 
             // TODO: allow the plugins to be just a list of paths or names
             // Do an async plugin queue like lessc
 
             if (options.plugins) {
-                options.plugins.forEach(function(plugin) {
-                    var evalResult, contents;
+                options.plugins.forEach(plugin => {
+                    let evalResult;
+                    let contents;
                     if (plugin.fileContent) {
                         contents = plugin.fileContent.replace(/^\uFEFF/, '');
                         evalResult = pluginManager.Loader.evalPlugin(contents, context, imports, plugin.options, plugin.filename);
@@ -81,7 +79,7 @@ module.exports = function(environment, ParseTree, ImportManager) {
             }
 
             new Parser(context, imports, rootFileInfo)
-                .parse(input, function (e, root) {
+                .parse(input, (e, root) => {
                     if (e) { return callback(e); }
                     callback(null, root, imports, options);
                 }, options);

package/lib/less/parser/chunker.js

@@ -1,12 +1,22 @@
 // Split the input into chunks.
-module.exports = function (input, fail) {
-    var len = input.length, level = 0, parenLevel = 0,
-        lastOpening, lastOpeningParen, lastMultiComment, lastMultiCommentEndBrace,
-        chunks = [], emitFrom = 0,
-        chunkerCurrentIndex, currentChunkStartIndex, cc, cc2, matched;
+export default (input, fail) => {
+    const len = input.length;
+    let level = 0;
+    let parenLevel = 0;
+    let lastOpening;
+    let lastOpeningParen;
+    let lastMultiComment;
+    let lastMultiCommentEndBrace;
+    const chunks = [];
+    let emitFrom = 0;
+    let chunkerCurrentIndex;
+    let currentChunkStartIndex;
+    let cc;
+    let cc2;
+    let matched;
 
     function emitChunk(force) {
-        var len = chunkerCurrentIndex - emitFrom;
+        const len = chunkerCurrentIndex - emitFrom;
         if (((len < 512) && !force) || !len) {
             return;
         }
@@ -64,7 +74,7 @@ module.exports = function (input, fail) {
                     }
                 }
                 if (matched) { continue; }
-                return fail('unmatched `' + String.fromCharCode(cc) + '`', currentChunkStartIndex);
+                return fail(`unmatched \`${String.fromCharCode(cc)}\``, currentChunkStartIndex);
             case 47:                        // /, check for comment
                 if (parenLevel || (chunkerCurrentIndex == len - 1)) { continue; }
                 cc2 = input.charCodeAt(chunkerCurrentIndex + 1);

package/lib/less/parser/parser-input.js

@@ -1,32 +1,50 @@
-var chunker = require('./chunker');
-
-module.exports = function() {
-    var input,       // Less input string
-        j,           // current chunk
-        saveStack = [],   // holds state for backtracking
-        furthest,    // furthest index the parser has gone to
-        furthestPossibleErrorMessage, // if this is furthest we got to, this is the probably cause
-        chunks,      // chunkified input
-        current,     // current chunk
-        currentPos,  // index of current chunk, in `input`
-        parserInput = {};
-
-    var CHARCODE_SPACE = 32,
-        CHARCODE_TAB = 9,
-        CHARCODE_LF = 10,
-        CHARCODE_CR = 13,
-        CHARCODE_PLUS = 43,
-        CHARCODE_COMMA = 44,
-        CHARCODE_FORWARD_SLASH = 47,
-        CHARCODE_9 = 57;
+import chunker from './chunker';
+
+export default () => {
+    let // Less input string
+        input;
+
+    let // current chunk
+        j;
+
+    const // holds state for backtracking
+        saveStack = [];
+
+    let // furthest index the parser has gone to
+        furthest;
+
+    let // if this is furthest we got to, this is the probably cause
+        furthestPossibleErrorMessage;
+
+    let // chunkified input
+        chunks;
+
+    let // current chunk
+        current;
+
+    let // index of current chunk, in `input`
+        currentPos;
+
+    const parserInput = {};
+    const CHARCODE_SPACE = 32;
+    const CHARCODE_TAB = 9;
+    const CHARCODE_LF = 10;
+    const CHARCODE_CR = 13;
+    const CHARCODE_PLUS = 43;
+    const CHARCODE_COMMA = 44;
+    const CHARCODE_FORWARD_SLASH = 47;
+    const CHARCODE_9 = 57;
 
     function skipWhitespace(length) {
-        var oldi = parserInput.i, oldj = j,
-            curr = parserInput.i - currentPos,
-            endIndex = parserInput.i + current.length - curr,
-            mem = (parserInput.i += length),
-            inp = input,
-            c, nextChar, comment;
+        const oldi = parserInput.i;
+        const oldj = j;
+        const curr = parserInput.i - currentPos;
+        const endIndex = parserInput.i + current.length - curr;
+        const mem = (parserInput.i += length);
+        const inp = input;
+        let c;
+        let nextChar;
+        let comment;
 
         for (; parserInput.i < endIndex; parserInput.i++) {
             c = inp.charCodeAt(parserInput.i);
@@ -35,7 +53,7 @@ module.exports = function() {
                 nextChar = inp.charAt(parserInput.i + 1);
                 if (nextChar === '/') {
                     comment = {index: parserInput.i, isLineComment: true};
-                    var nextNewLine = inp.indexOf('\n', parserInput.i + 2);
+                    let nextNewLine = inp.indexOf('\n', parserInput.i + 2);
                     if (nextNewLine < 0) {
                         nextNewLine = endIndex;
                     }
@@ -44,7 +62,7 @@ module.exports = function() {
                     parserInput.commentStore.push(comment);
                     continue;
                 } else if (nextChar === '*') {
-                    var nextStarSlash = inp.indexOf('*/', parserInput.i + 2);
+                    const nextStarSlash = inp.indexOf('*/', parserInput.i + 2);
                     if (nextStarSlash >= 0) {
                         comment = {
                             index: parserInput.i,
@@ -79,38 +97,38 @@ module.exports = function() {
         return oldi !== parserInput.i || oldj !== j;
     }
 
-    parserInput.save = function() {
+    parserInput.save = () => {
         currentPos = parserInput.i;
-        saveStack.push( { current: current, i: parserInput.i, j: j });
+        saveStack.push( { current, i: parserInput.i, j });
     };
-    parserInput.restore = function(possibleErrorMessage) {
+    parserInput.restore = possibleErrorMessage => {
 
         if (parserInput.i > furthest || (parserInput.i === furthest && possibleErrorMessage && !furthestPossibleErrorMessage)) {
             furthest = parserInput.i;
             furthestPossibleErrorMessage = possibleErrorMessage;
         }
-        var state = saveStack.pop();
+        const state = saveStack.pop();
         current = state.current;
         currentPos = parserInput.i = state.i;
         j = state.j;
     };
-    parserInput.forget = function() {
+    parserInput.forget = () => {
         saveStack.pop();
     };
-    parserInput.isWhitespace = function (offset) {
-        var pos = parserInput.i + (offset || 0),
-            code = input.charCodeAt(pos);
+    parserInput.isWhitespace = offset => {
+        const pos = parserInput.i + (offset || 0);
+        const code = input.charCodeAt(pos);
         return (code === CHARCODE_SPACE || code === CHARCODE_CR || code === CHARCODE_TAB || code === CHARCODE_LF);
     };
 
     // Specialization of $(tok)
-    parserInput.$re = function(tok) {
+    parserInput.$re = tok => {
         if (parserInput.i > currentPos) {
             current = current.slice(parserInput.i - currentPos);
             currentPos = parserInput.i;
         }
 
-        var m = tok.exec(current);
+        const m = tok.exec(current);
         if (!m) {
             return null;
         }
@@ -123,7 +141,7 @@ module.exports = function() {
         return m.length === 1 ? m[0] : m;
     };
 
-    parserInput.$char = function(tok) {
+    parserInput.$char = tok => {
         if (input.charAt(parserInput.i) !== tok) {
             return null;
         }
@@ -131,11 +149,11 @@ module.exports = function() {
         return tok;
     };
 
-    parserInput.$str = function(tok) {
-        var tokLength = tok.length;
+    parserInput.$str = tok => {
+        const tokLength = tok.length;
 
         // https://jsperf.com/string-startswith/21
-        for (var i = 0; i < tokLength; i++) {
+        for (let i = 0; i < tokLength; i++) {
             if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
                 return null;
             }
@@ -145,18 +163,18 @@ module.exports = function() {
         return tok;
     };
 
-    parserInput.$quoted = function(loc) {
-        var pos = loc || parserInput.i,
-            startChar = input.charAt(pos);
+    parserInput.$quoted = loc => {
+        const pos = loc || parserInput.i;
+        const startChar = input.charAt(pos);
 
         if (startChar !== '\'' && startChar !== '"') {
             return;
         }
-        var length = input.length,
-            currentPosition = pos;
+        const length = input.length;
+        const currentPosition = pos;
 
-        for (var i = 1; i + currentPosition < length; i++) {
-            var nextChar = input.charAt(i + currentPosition);
+        for (let i = 1; i + currentPosition < length; i++) {
+            const nextChar = input.charAt(i + currentPosition);
             switch (nextChar) {
                 case '\\':
                     i++;
@@ -165,7 +183,7 @@ module.exports = function() {
                 case '\n':
                     break;
                 case startChar:
-                    var str = input.substr(currentPosition, i + 1);
+                    const str = input.substr(currentPosition, i + 1);
                     if (!loc && loc !== 0) {
                         skipWhitespace(i + 1);
                         return str
@@ -181,32 +199,29 @@ module.exports = function() {
      * Permissive parsing. Ignores everything except matching {} [] () and quotes
      * until matching token (outside of blocks)
      */
-    parserInput.$parseUntil = function(tok) {
-        var quote = '',
-            returnVal = null,
-            inComment = false,
-            blockDepth = 0,
-            blockStack = [],
-            parseGroups = [],
-            length = input.length,
-            startPos = parserInput.i,
-            lastPos = parserInput.i,
-            i = parserInput.i,
-            loop = true,
-            testChar;
+    parserInput.$parseUntil = tok => {
+        let quote = '';
+        let returnVal = null;
+        let inComment = false;
+        let blockDepth = 0;
+        const blockStack = [];
+        const parseGroups = [];
+        const length = input.length;
+        const startPos = parserInput.i;
+        let lastPos = parserInput.i;
+        let i = parserInput.i;
+        let loop = true;
+        let testChar;
 
         if (typeof tok === 'string') {
-            testChar = function(char) {
-                return char === tok;
-            }
+            testChar = char => char === tok
         } else {
-            testChar = function(char) {
-                return tok.test(char);
-            }
+            testChar = char => tok.test(char)
         }
 
         do {
-            var prevChar, nextChar = input.charAt(i);
+            let prevChar;
+            let nextChar = input.charAt(i);
             if (blockDepth === 0 && testChar(nextChar)) {
                 returnVal = input.substr(lastPos, i - lastPos);
                 if (returnVal) {
@@ -272,7 +287,7 @@ module.exports = function() {
                     case '}':
                     case ')':
                     case ']':
-                        var expected = blockStack.pop();
+                        const expected = blockStack.pop();
                         if (nextChar === expected) {
                             blockDepth--;
                         } else {
@@ -299,10 +314,10 @@ module.exports = function() {
 
     // Same as $(), but don't change the state of the parser,
     // just return the match.
-    parserInput.peek = function(tok) {
+    parserInput.peek = tok => {
         if (typeof tok === 'string') {
             // https://jsperf.com/string-startswith/21
-            for (var i = 0; i < tok.length; i++) {
+            for (let i = 0; i < tok.length; i++) {
                 if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
                     return false;
                 }
@@ -315,29 +330,21 @@ module.exports = function() {
 
     // Specialization of peek()
     // TODO remove or change some currentChar calls to peekChar
-    parserInput.peekChar = function(tok) {
-        return input.charAt(parserInput.i) === tok;
-    };
+    parserInput.peekChar = tok => input.charAt(parserInput.i) === tok;
 
-    parserInput.currentChar = function() {
-        return input.charAt(parserInput.i);
-    };
+    parserInput.currentChar = () => input.charAt(parserInput.i);
 
-    parserInput.prevChar = function() {
-        return input.charAt(parserInput.i - 1);
-    };
+    parserInput.prevChar = () => input.charAt(parserInput.i - 1);
 
-    parserInput.getInput = function() {
-        return input;
-    };
+    parserInput.getInput = () => input;
 
-    parserInput.peekNotNumeric = function() {
-        var c = input.charCodeAt(parserInput.i);
+    parserInput.peekNotNumeric = () => {
+        const c = input.charCodeAt(parserInput.i);
         // Is the first char of the dimension 0-9, '.', '+' or '-'
         return (c > CHARCODE_9 || c < CHARCODE_PLUS) || c === CHARCODE_FORWARD_SLASH || c === CHARCODE_COMMA;
     };
 
-    parserInput.start = function(str, chunkInput, failFunction) {
+    parserInput.start = (str, chunkInput, failFunction) => {
         input = str;
         parserInput.i = j = currentPos = furthest = 0;
 
@@ -362,16 +369,16 @@ module.exports = function() {
         skipWhitespace(0);
     };
 
-    parserInput.end = function() {
-        var message,
-            isFinished = parserInput.i >= input.length;
+    parserInput.end = () => {
+        let message;
+        const isFinished = parserInput.i >= input.length;
 
         if (parserInput.i < furthest) {
             message = furthestPossibleErrorMessage;
             parserInput.i = furthest;
         }
         return {
-            isFinished: isFinished,
+            isFinished,
             furthest: parserInput.i,
             furthestPossibleErrorMessage: message,
             furthestReachedEnd: parserInput.i >= input.length - 1,