less 3.9.0 → 3.10.1

package/lib/less-browser/log-listener.js

@@ -1,9 +1,8 @@
-module.exports = function(less, options) {
-
-    var logLevel_debug = 4,
-        logLevel_info = 3,
-        logLevel_warn = 2,
-        logLevel_error = 1;
+export default (less, options) => {
+    const logLevel_debug = 4;
+    const logLevel_info = 3;
+    const logLevel_warn = 2;
+    const logLevel_error = 1;
 
     // The amount of logging in the javascript console.
     // 3 - Debug, information and errors
@@ -37,7 +36,7 @@ module.exports = function(less, options) {
             }
         }];
     }
-    for (var i = 0; i < options.loggers.length; i++) {
+    for (let i = 0; i < options.loggers.length; i++) {
         less.logger.addListener(options.loggers[i]);
     }
 };

package/lib/less-browser/plugin-loader.js

@@ -1,24 +1,26 @@
 // TODO: Add tests for browser @plugin
 /* global window */
 
-var AbstractPluginLoader = require('../less/environment/abstract-plugin-loader.js');
+import AbstractPluginLoader from '../less/environment/abstract-plugin-loader.js';
 
 /**
  * Browser Plugin Loader
  */
-var PluginLoader = function(less) {
-    this.less = less;
-    // Should we shim this.require for browser? Probably not?
-};
+class PluginLoader extends AbstractPluginLoader {
+    constructor(less) {
+        super();
 
-PluginLoader.prototype = new AbstractPluginLoader();
+        this.less = less;
+        // Should we shim this.require for browser? Probably not?
+    }
 
-PluginLoader.prototype.loadPlugin = function(filename, basePath, context, environment, fileManager) {
-    return new Promise(function(fulfill, reject) {
-        fileManager.loadFile(filename, basePath, context, environment)
-            .then(fulfill).catch(reject);
-    });
-};
+    loadPlugin(filename, basePath, context, environment, fileManager) {
+        return new Promise((fulfill, reject) => {
+            fileManager.loadFile(filename, basePath, context, environment)
+                .then(fulfill).catch(reject);
+        });
+    }
+}
 
-module.exports = PluginLoader;
+export default PluginLoader;
 

package/lib/less-browser/utils.js

@@ -1,24 +1,24 @@
-module.exports = {
-    extractId: function(href) {
-        return href.replace(/^[a-z-]+:\/+?[^\/]+/, '')  // Remove protocol & domain
-            .replace(/[\?\&]livereload=\w+/, '')        // Remove LiveReload cachebuster
-            .replace(/^\//, '')                         // Remove root /
-            .replace(/\.[a-zA-Z]+$/, '')                // Remove simple extension
-            .replace(/[^\.\w-]+/g, '-')                 // Replace illegal characters
-            .replace(/\./g, ':');                       // Replace dots with colons(for valid id)
-    },
-    addDataAttr: function(options, tag) {
-        for (var opt in tag.dataset) {
-            if (tag.dataset.hasOwnProperty(opt)) {
-                if (opt === 'env' || opt === 'dumpLineNumbers' || opt === 'rootpath' || opt === 'errorReporting') {
-                    options[opt] = tag.dataset[opt];
-                } else {
-                    try {
-                        options[opt] = JSON.parse(tag.dataset[opt]);
-                    }
-                    catch (_) {}
+
+export function extractId(href) {
+    return href.replace(/^[a-z-]+:\/+?[^\/]+/, '')  // Remove protocol & domain
+        .replace(/[\?\&]livereload=\w+/, '')        // Remove LiveReload cachebuster
+        .replace(/^\//, '')                         // Remove root /
+        .replace(/\.[a-zA-Z]+$/, '')                // Remove simple extension
+        .replace(/[^\.\w-]+/g, '-')                 // Replace illegal characters
+        .replace(/\./g, ':');                       // Replace dots with colons(for valid id)
+}
+
+export function addDataAttr(options, tag) {
+    for (const opt in tag.dataset) {
+        if (tag.dataset.hasOwnProperty(opt)) {
+            if (opt === 'env' || opt === 'dumpLineNumbers' || opt === 'rootpath' || opt === 'errorReporting') {
+                options[opt] = tag.dataset[opt];
+            } else {
+                try {
+                    options[opt] = JSON.parse(tag.dataset[opt]);
                 }
+                catch (_) {}
             }
         }
     }
-};
+}

package/lib/less-node/environment.js

@@ -1,6 +1,8 @@
-module.exports = {
+export default {
     encodeBase64: function encodeBase64(str) {
-        return new Buffer(str).toString('base64');
+        // Avoid Buffer constructor on newer versions of Node.js.
+        const buffer = (Buffer.from ? Buffer.from(str) : (new Buffer(str)));
+        return buffer.toString('base64');
     },
     mimeLookup: function (filename) {
         return require('mime').lookup(filename);

package/lib/less-node/file-manager.js

@@ -1,176 +1,177 @@
-var path = require('path'),
-    fs = require('./fs'),
-    PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise,
-    AbstractFileManager = require('../less/environment/abstract-file-manager.js');
+import path from 'path';
+import fs from './fs';
+import AbstractFileManager from '../less/environment/abstract-file-manager.js';
 
-var FileManager = function() {
-    this.contents = {};
-};
+class FileManager extends AbstractFileManager {
+    constructor() {
+        super();
 
-FileManager.prototype = new AbstractFileManager();
+        this.contents = {};
+    }
 
-FileManager.prototype.supports = function(filename, currentDirectory, options, environment) {
-    return true;
-};
-FileManager.prototype.supportsSync = function(filename, currentDirectory, options, environment) {
-    return true;
-};
+    supports(filename, currentDirectory, options, environment) {
+        return true;
+    }
 
-FileManager.prototype.loadFile = function(filename, currentDirectory, options, environment, callback) {
+    supportsSync(filename, currentDirectory, options, environment) {
+        return true;
+    }
 
-    var fullFilename,
-        isAbsoluteFilename = this.isPathAbsolute(filename),
-        filenamesTried = [],
-        self = this,
-        prefix = filename.slice(0, 1),
-        explicit = prefix === '.' || prefix === '/',
-        result = null,
-        isNodeModule = false,
-        npmPrefix = 'npm://';
+    loadFile(filename, currentDirectory, options, environment, callback) {
+        let fullFilename;
+        const isAbsoluteFilename = this.isPathAbsolute(filename);
+        const filenamesTried = [];
+        const self = this;
+        const prefix = filename.slice(0, 1);
+        const explicit = prefix === '.' || prefix === '/';
+        let result = null;
+        let isNodeModule = false;
+        const npmPrefix = 'npm://';
 
-    options = options || {};
+        options = options || {};
 
-    var paths = isAbsoluteFilename ? [''] : [currentDirectory];
+        const paths = isAbsoluteFilename ? [''] : [currentDirectory];
 
-    if (options.paths) { paths.push.apply(paths, options.paths); }
+        if (options.paths) { paths.push(...options.paths); }
 
-    if (!isAbsoluteFilename && paths.indexOf('.') === -1) { paths.push('.'); }
+        if (!isAbsoluteFilename && paths.indexOf('.') === -1) { paths.push('.'); }
 
-    var prefixes = options.prefixes || [''];
-    var fileParts = this.extractUrlParts(filename);
+        const prefixes = options.prefixes || [''];
+        const fileParts = this.extractUrlParts(filename);
 
-    if (options.syncImport) {
-        getFileData(returnData, returnData);
-        if (callback) {
-            callback(result.error, result);
+        if (options.syncImport) {
+            getFileData(returnData, returnData);
+            if (callback) {
+                callback(result.error, result);
+            }
+            else {
+                return result;
+            }
         }
         else {
-            return result;
+            // promise is guaranteed to be asyncronous
+            // which helps as it allows the file handle
+            // to be closed before it continues with the next file
+            return new Promise(getFileData);
         }
-    }
-    else {
-        // promise is guaranteed to be asyncronous
-        // which helps as it allows the file handle
-        // to be closed before it continues with the next file
-        return new PromiseConstructor(getFileData);
-    }
 
-    function returnData(data) {
-        if (!data.filename) {
-            result = { error: data };
-        }
-        else {
-            result = data;
+        function returnData(data) {
+            if (!data.filename) {
+                result = { error: data };
+            }
+            else {
+                result = data;
+            }
         }
-    }
 
-    function getFileData(fulfill, reject) {
-        (function tryPathIndex(i) {
-            if (i < paths.length) {
-                (function tryPrefix(j) {
-                    if (j < prefixes.length) {
-                        isNodeModule = false;
-                        fullFilename = fileParts.rawPath + prefixes[j] + fileParts.filename;
+        function getFileData(fulfill, reject) {
+            (function tryPathIndex(i) {
+                if (i < paths.length) {
+                    (function tryPrefix(j) {
+                        if (j < prefixes.length) {
+                            isNodeModule = false;
+                            fullFilename = fileParts.rawPath + prefixes[j] + fileParts.filename;
 
-                        if (paths[i]) {
-                            fullFilename = path.join(paths[i], fullFilename);
-                        }
-
-                        if (!explicit && paths[i] === '.') {
-                            try {
-                                fullFilename = require.resolve(fullFilename);
-                                isNodeModule = true;
-                            }
-                            catch (e) {
-                                filenamesTried.push(npmPrefix + fullFilename);
-                                tryWithExtension();
+                            if (paths[i]) {
+                                fullFilename = path.join(paths[i], fullFilename);
                             }
-                        }
-                        else {
-                            tryWithExtension();
-                        }
 
-                        function tryWithExtension() {
-                            var extFilename = options.ext ? self.tryAppendExtension(fullFilename, options.ext) : fullFilename;
-
-                            if (extFilename !== fullFilename && !explicit && paths[i] === '.') {
+                            if (!explicit && paths[i] === '.') {
                                 try {
-                                    fullFilename = require.resolve(extFilename);
+                                    fullFilename = require.resolve(fullFilename);
                                     isNodeModule = true;
                                 }
                                 catch (e) {
-                                    filenamesTried.push(npmPrefix + extFilename);
-                                    fullFilename = extFilename;
+                                    filenamesTried.push(npmPrefix + fullFilename);
+                                    tryWithExtension();
                                 }
                             }
                             else {
-                                fullFilename = extFilename;
+                                tryWithExtension();
                             }
-                        }
 
-                        var modified = false;
+                            function tryWithExtension() {
+                                const extFilename = options.ext ? self.tryAppendExtension(fullFilename, options.ext) : fullFilename;
 
-                        if (self.contents[fullFilename]) {
-                            try {
-                                var stat = fs.statSync.apply(this, [fullFilename]);
-                                if (stat.mtime.getTime() === self.contents[fullFilename].mtime.getTime()) {
-                                    fulfill({ contents: self.contents[fullFilename].data, filename: fullFilename});
+                                if (extFilename !== fullFilename && !explicit && paths[i] === '.') {
+                                    try {
+                                        fullFilename = require.resolve(extFilename);
+                                        isNodeModule = true;
+                                    }
+                                    catch (e) {
+                                        filenamesTried.push(npmPrefix + extFilename);
+                                        fullFilename = extFilename;
+                                    }
                                 }
                                 else {
-                                    modified = true;
+                                    fullFilename = extFilename;
                                 }
                             }
-                            catch (e) {
-                                modified = true;
-                            }
-                        }
-                        if (modified || !self.contents[fullFilename]) {
-                            var readFileArgs = [fullFilename];
-                            if (!options.rawBuffer) {
-                                readFileArgs.push('utf-8');
-                            }
-                            if (options.syncImport) {
+
+                            let modified = false;
+
+                            if (self.contents[fullFilename]) {
                                 try {
-                                    var data = fs.readFileSync.apply(this, readFileArgs);
                                     var stat = fs.statSync.apply(this, [fullFilename]);
-                                    self.contents[fullFilename] = { data: data, mtime: stat.mtime };
-                                    fulfill({ contents: data, filename: fullFilename});
+                                    if (stat.mtime.getTime() === self.contents[fullFilename].mtime.getTime()) {
+                                        fulfill({ contents: self.contents[fullFilename].data, filename: fullFilename});
+                                    }
+                                    else {
+                                        modified = true;
+                                    }
                                 }
                                 catch (e) {
-                                    filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);
-                                    return tryPrefix(j + 1);
+                                    modified = true;
                                 }
                             }
-                            else {
-                                readFileArgs.push(function(e, data) {
-                                    if (e) {
+                            if (modified || !self.contents[fullFilename]) {
+                                const readFileArgs = [fullFilename];
+                                if (!options.rawBuffer) {
+                                    readFileArgs.push('utf-8');
+                                }
+                                if (options.syncImport) {
+                                    try {
+                                        const data = fs.readFileSync.apply(this, readFileArgs);
+                                        var stat = fs.statSync.apply(this, [fullFilename]);
+                                        self.contents[fullFilename] = { data, mtime: stat.mtime };
+                                        fulfill({ contents: data, filename: fullFilename});
+                                    }
+                                    catch (e) {
                                         filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);
                                         return tryPrefix(j + 1);
                                     }
-                                    var stat = fs.statSync.apply(this, [fullFilename]);
-                                    self.contents[fullFilename] = { data: data, mtime: stat.mtime };      
-                                    fulfill({ contents: data, filename: fullFilename});
-                                });
-                                fs.readFile.apply(this, readFileArgs);
+                                }
+                                else {
+                                    readFileArgs.push(function(e, data) {
+                                        if (e) {
+                                            filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);
+                                            return tryPrefix(j + 1);
+                                        }
+                                        const stat = fs.statSync.apply(this, [fullFilename]);
+                                        self.contents[fullFilename] = { data, mtime: stat.mtime };      
+                                        fulfill({ contents: data, filename: fullFilename});
+                                    });
+                                    fs.readFile.apply(this, readFileArgs);
+                                }
+
                             }
 
                         }
-
-                    }
-                    else {
-                        tryPathIndex(i + 1);
-                    }
-                })(0);
-            } else {
-                reject({ type: 'File', message: '\'' + filename + '\' wasn\'t found. Tried - ' + filenamesTried.join(',') });
-            }
-        }(0));
+                        else {
+                            tryPathIndex(i + 1);
+                        }
+                    })(0);
+                } else {
+                    reject({ type: 'File', message: `'${filename}' wasn't found. Tried - ${filenamesTried.join(',')}` });
+                }
+            }(0));
+        }
     }
-};
 
-FileManager.prototype.loadFileSync = function(filename, currentDirectory, options, environment) {
-    options.syncImport = true;
-    return this.loadFile(filename, currentDirectory, options, environment);
-};
+    loadFileSync(filename, currentDirectory, options, environment) {
+        options.syncImport = true;
+        return this.loadFile(filename, currentDirectory, options, environment);
+    }
+}
 
-module.exports = FileManager;
+export default FileManager;

package/lib/less-node/fs.js

@@ -1,4 +1,4 @@
-var fs;
+let fs;
 try
 {
     fs = require('graceful-fs');
@@ -7,4 +7,4 @@ catch (e)
 {
     fs = require('fs');
 }
-module.exports = fs;
+export default fs;

package/lib/less-node/image-size.js

@@ -1,54 +1,55 @@
-module.exports = function(environment) {
-    var Dimension = require('../less/tree/dimension'),
-        Expression = require('../less/tree/expression'),
-        functionRegistry = require('./../less/functions/function-registry');
+import Dimension from '../less/tree/dimension';
+import Expression from '../less/tree/expression';
+import functionRegistry from './../less/functions/function-registry';
+
+export default environment => {
 
     function imageSize(functionContext, filePathNode) {
-        var filePath = filePathNode.value;
-        var currentFileInfo = functionContext.currentFileInfo;
-        var currentDirectory = currentFileInfo.rewriteUrls ?
-        currentFileInfo.currentDirectory : currentFileInfo.entryPath;
+        let filePath = filePathNode.value;
+        const currentFileInfo = functionContext.currentFileInfo;
+        const currentDirectory = currentFileInfo.rewriteUrls ?
+            currentFileInfo.currentDirectory : currentFileInfo.entryPath;
 
-        var fragmentStart = filePath.indexOf('#');
-        var fragment = '';
+        const fragmentStart = filePath.indexOf('#');
+        let fragment = '';
         if (fragmentStart !== -1) {
             fragment = filePath.slice(fragmentStart);
             filePath = filePath.slice(0, fragmentStart);
         }
 
-        var fileManager = environment.getFileManager(filePath, currentDirectory, functionContext.context, environment, true);
+        const fileManager = environment.getFileManager(filePath, currentDirectory, functionContext.context, environment, true);
 
         if (!fileManager) {
             throw {
                 type: 'File',
-                message: 'Can not set up FileManager for ' + filePathNode
+                message: `Can not set up FileManager for ${filePathNode}`
             };
         }
 
-        var fileSync = fileManager.loadFileSync(filePath, currentDirectory, functionContext.context, environment);
+        const fileSync = fileManager.loadFileSync(filePath, currentDirectory, functionContext.context, environment);
 
         if (fileSync.error) {
             throw fileSync.error;
         }
 
-        var sizeOf = require('image-size');
+        const sizeOf = require('image-size');
         return sizeOf(fileSync.filename);
     }
 
-    var imageFunctions = {
+    const imageFunctions = {
         'image-size': function(filePathNode) {
-            var size = imageSize(this, filePathNode);
+            const size = imageSize(this, filePathNode);
             return new Expression([
                 new Dimension(size.width, 'px'),
                 new Dimension(size.height, 'px')
             ]);
         },
         'image-width': function(filePathNode) {
-            var size = imageSize(this, filePathNode);
+            const size = imageSize(this, filePathNode);
             return new Dimension(size.width, 'px');
         },
         'image-height': function(filePathNode) {
-            var size = imageSize(this, filePathNode);
+            const size = imageSize(this, filePathNode);
             return new Dimension(size.height, 'px');
         }
     };

package/lib/less-node/index.js

@@ -1,23 +1,27 @@
-var environment = require('./environment'),
-    FileManager = require('./file-manager'),
-    UrlFileManager = require('./url-file-manager'),
-    createFromEnvironment = require('../less'),
-    less = createFromEnvironment(environment, [new FileManager(), new UrlFileManager()]),
-    lesscHelper = require('./lessc-helper'),
-    path = require('path');
+import environment from './environment';
+import FileManager from './file-manager';
+import UrlFileManager from './url-file-manager';
+import createFromEnvironment from '../less';
+import lesscHelper from './lessc-helper';
+import PluginLoader from './plugin-loader';
+import fs from './fs';
+import defaultOptions from '../less/default-options';
+import imageSize from './image-size';
+
+const less = createFromEnvironment(environment, [new FileManager(), new UrlFileManager()]);
 
 // allow people to create less with their own environment
 less.createFromEnvironment = createFromEnvironment;
 less.lesscHelper = lesscHelper;
-less.PluginLoader = require('./plugin-loader');
-less.fs = require('./fs');
+less.PluginLoader = PluginLoader;
+less.fs = fs;
 less.FileManager = FileManager;
 less.UrlFileManager = UrlFileManager;
 
 // Set up options
-less.options = require('../less/default-options')();
+less.options = defaultOptions();
 
 // provide image-size functionality
-require('./image-size')(less.environment);
+imageSize(less.environment);
 
-module.exports = less;
+export default less;

package/lib/less-node/lessc-helper.js

@@ -1,11 +1,11 @@
 // lessc_helper.js
 //
 //      helper functions for lessc
-var lessc_helper = {
+const lessc_helper = {
 
     // Stylize a string
     stylize : function(str, style) {
-        var styles = {
+        const styles = {
             'reset'     : [0,   0],
             'bold'      : [1,  22],
             'inverse'   : [7,  27],
@@ -15,8 +15,7 @@ var lessc_helper = {
             'red'       : [31, 39],
             'grey'      : [90, 39]
         };
-        return '\x1b[' + styles[style][0] + 'm' + str +
-               '\x1b[' + styles[style][1] + 'm';
+        return `\x1b[${styles[style][0]}m${str}\x1b[${styles[style][1]}m`;
     },
 
     // Print command line options
@@ -87,4 +86,4 @@ var lessc_helper = {
 };
 
 // Exports helper functions
-for (var h in lessc_helper) { if (lessc_helper.hasOwnProperty(h)) { exports[h] = lessc_helper[h]; }}
+for (const h in lessc_helper) { if (lessc_helper.hasOwnProperty(h)) { exports[h] = lessc_helper[h]; }}