less 3.9.0 → 3.10.1

package/lib/less/environment/abstract-file-manager.js

@@ -1,123 +1,127 @@
-var abstractFileManager = function() {
-};
-
-abstractFileManager.prototype.getPath = function (filename) {
-    var j = filename.lastIndexOf('?');
-    if (j > 0) {
-        filename = filename.slice(0, j);
-    }
-    j = filename.lastIndexOf('/');
-    if (j < 0) {
-        j = filename.lastIndexOf('\\');
-    }
-    if (j < 0) {
-        return '';
+class AbstractFileManager {
+    getPath(filename) {
+        let j = filename.lastIndexOf('?');
+        if (j > 0) {
+            filename = filename.slice(0, j);
+        }
+        j = filename.lastIndexOf('/');
+        if (j < 0) {
+            j = filename.lastIndexOf('\\');
+        }
+        if (j < 0) {
+            return '';
+        }
+        return filename.slice(0, j + 1);
     }
-    return filename.slice(0, j + 1);
-};
-
-abstractFileManager.prototype.tryAppendExtension = function(path, ext) {
-    return /(\.[a-z]*$)|([\?;].*)$/.test(path) ? path : path + ext;
-};
-
-abstractFileManager.prototype.tryAppendLessExtension = function(path) {
-    return this.tryAppendExtension(path, '.less');
-};
-
-abstractFileManager.prototype.supportsSync = function() {
-    return false;
-};
-
-abstractFileManager.prototype.alwaysMakePathsAbsolute = function() {
-    return false;
-};
-
-abstractFileManager.prototype.isPathAbsolute = function(filename) {
-    return (/^(?:[a-z-]+:|\/|\\|#)/i).test(filename);
-};
-// TODO: pull out / replace?
-abstractFileManager.prototype.join = function(basePath, laterPath) {
-    if (!basePath) {
-        return laterPath;
+
+    tryAppendExtension(path, ext) {
+        return /(\.[a-z]*$)|([\?;].*)$/.test(path) ? path : path + ext;
     }
-    return basePath + laterPath;
-};
 
-abstractFileManager.prototype.pathDiff = function pathDiff(url, baseUrl) {
-    // diff between two paths to create a relative path
+    tryAppendLessExtension(path) {
+        return this.tryAppendExtension(path, '.less');
+    };
 
-    var urlParts = this.extractUrlParts(url),
-        baseUrlParts = this.extractUrlParts(baseUrl),
-        i, max, urlDirectories, baseUrlDirectories, diff = '';
-    if (urlParts.hostPart !== baseUrlParts.hostPart) {
-        return '';
-    }
-    max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
-    for (i = 0; i < max; i++) {
-        if (baseUrlParts.directories[i] !== urlParts.directories[i]) { break; }
-    }
-    baseUrlDirectories = baseUrlParts.directories.slice(i);
-    urlDirectories = urlParts.directories.slice(i);
-    for (i = 0; i < baseUrlDirectories.length - 1; i++) {
-        diff += '../';
-    }
-    for (i = 0; i < urlDirectories.length - 1; i++) {
-        diff += urlDirectories[i] + '/';
-    }
-    return diff;
-};
-// helper function, not part of API
-abstractFileManager.prototype.extractUrlParts = function extractUrlParts(url, baseUrl) {
-    // urlParts[1] = protocol://hostname/ OR /
-    // urlParts[2] = / if path relative to host base
-    // urlParts[3] = directories
-    // urlParts[4] = filename
-    // urlParts[5] = parameters
-
-    var urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i,
-        urlParts = url.match(urlPartsRegex),
-        returner = {}, rawDirectories = [], directories = [], i, baseUrlParts;
-
-    if (!urlParts) {
-        throw new Error('Could not parse sheet href - \'' + url + '\'');
-    }
+    supportsSync() { return false; }
+
+    alwaysMakePathsAbsolute() { return false; }
 
-    // Stylesheets in IE don't always return the full path
-    if (baseUrl && (!urlParts[1] || urlParts[2])) {
-        baseUrlParts = baseUrl.match(urlPartsRegex);
-        if (!baseUrlParts) {
-            throw new Error('Could not parse page url - \'' + baseUrl + '\'');
+    isPathAbsolute(filename) {
+        return (/^(?:[a-z-]+:|\/|\\|#)/i).test(filename);
+    }
+    // TODO: pull out / replace?
+    join(basePath, laterPath) {
+        if (!basePath) {
+            return laterPath;
         }
-        urlParts[1] = urlParts[1] || baseUrlParts[1] || '';
-        if (!urlParts[2]) {
-            urlParts[3] = baseUrlParts[3] + urlParts[3];
+        return basePath + laterPath;
+    };
+
+    pathDiff(url, baseUrl) {
+        // diff between two paths to create a relative path
+        const urlParts = this.extractUrlParts(url);
+        const baseUrlParts = this.extractUrlParts(baseUrl);
+
+        let i;
+        let max;
+        let urlDirectories;
+        let baseUrlDirectories;
+        let diff = '';
+        if (urlParts.hostPart !== baseUrlParts.hostPart) {
+            return '';
+        }
+        max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
+        for (i = 0; i < max; i++) {
+            if (baseUrlParts.directories[i] !== urlParts.directories[i]) { break; }
+        }
+        baseUrlDirectories = baseUrlParts.directories.slice(i);
+        urlDirectories = urlParts.directories.slice(i);
+        for (i = 0; i < baseUrlDirectories.length - 1; i++) {
+            diff += '../';
+        }
+        for (i = 0; i < urlDirectories.length - 1; i++) {
+            diff += `${urlDirectories[i]}/`;
+        }
+        return diff;
+    };
+    // helper function, not part of API
+    extractUrlParts(url, baseUrl) {
+        // urlParts[1] = protocol://hostname/ OR /
+        // urlParts[2] = / if path relative to host base
+        // urlParts[3] = directories
+        // urlParts[4] = filename
+        // urlParts[5] = parameters
+
+        const urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i;
+
+        const urlParts = url.match(urlPartsRegex);
+        const returner = {};
+        let rawDirectories = [];
+        const directories = [];
+        let i;
+        let baseUrlParts;
+
+        if (!urlParts) {
+            throw new Error(`Could not parse sheet href - '${url}'`);
         }
-    }
 
-    if (urlParts[3]) {
-        rawDirectories = urlParts[3].replace(/\\/g, '/').split('/');
+        // Stylesheets in IE don't always return the full path
+        if (baseUrl && (!urlParts[1] || urlParts[2])) {
+            baseUrlParts = baseUrl.match(urlPartsRegex);
+            if (!baseUrlParts) {
+                throw new Error(`Could not parse page url - '${baseUrl}'`);
+            }
+            urlParts[1] = urlParts[1] || baseUrlParts[1] || '';
+            if (!urlParts[2]) {
+                urlParts[3] = baseUrlParts[3] + urlParts[3];
+            }
+        }
 
-        // collapse '..' and skip '.'
-        for (i = 0; i < rawDirectories.length; i++) {
+        if (urlParts[3]) {
+            rawDirectories = urlParts[3].replace(/\\/g, '/').split('/');
 
-            if (rawDirectories[i] === '..') {
-                directories.pop();
-            }
-            else if (rawDirectories[i] !== '.') {
-                directories.push(rawDirectories[i]);
+            // collapse '..' and skip '.'
+            for (i = 0; i < rawDirectories.length; i++) {
+
+                if (rawDirectories[i] === '..') {
+                    directories.pop();
+                }
+                else if (rawDirectories[i] !== '.') {
+                    directories.push(rawDirectories[i]);
+                }
+            
             }
-        
         }
-    }
 
-    returner.hostPart = urlParts[1];
-    returner.directories = directories;
-    returner.rawPath = (urlParts[1] || '') + rawDirectories.join('/');
-    returner.path = (urlParts[1] || '') + directories.join('/');
-    returner.filename = urlParts[4];
-    returner.fileUrl = returner.path + (urlParts[4] || '');
-    returner.url = returner.fileUrl + (urlParts[5] || '');
-    return returner;
-};
-
-module.exports = abstractFileManager;
+        returner.hostPart = urlParts[1];
+        returner.directories = directories;
+        returner.rawPath = (urlParts[1] || '') + rawDirectories.join('/');
+        returner.path = (urlParts[1] || '') + directories.join('/');
+        returner.filename = urlParts[4];
+        returner.fileUrl = returner.path + (urlParts[4] || '');
+        returner.url = returner.fileUrl + (urlParts[5] || '');
+        return returner;
+    };
+}
+
+export default AbstractFileManager;

package/lib/less/environment/abstract-plugin-loader.js

@@ -1,43 +1,105 @@
-var functionRegistry = require('../functions/function-registry'),
-    LessError = require('../less-error');
+import functionRegistry from '../functions/function-registry';
+import LessError from '../less-error';
 
-var AbstractPluginLoader = function() {
-    // Implemented by Node.js plugin loader
-    this.require = function() {
-        return null;
+class AbstractPluginLoader {
+    constructor() {
+        // Implemented by Node.js plugin loader
+        this.require = () => null
     }
-};
 
-AbstractPluginLoader.prototype.evalPlugin = function(contents, context, imports, pluginOptions, fileInfo) {
+    evalPlugin(contents, context, imports, pluginOptions, fileInfo) {
+        let loader;
+        let registry;
+        let pluginObj;
+        let localModule;
+        let pluginManager;
+        let filename;
+        let result;
+
+        pluginManager = context.pluginManager;
 
-    var loader,
-        registry,
-        pluginObj,
-        localModule,
-        pluginManager,
-        filename,
-        result;
+        if (fileInfo) {
+            if (typeof fileInfo === 'string') {
+                filename = fileInfo;
+            }
+            else {
+                filename = fileInfo.filename;
+            }
+        }
+        const shortname = (new this.less.FileManager()).extractUrlParts(filename).filename;
 
-    pluginManager = context.pluginManager;
+        if (filename) {
+            pluginObj = pluginManager.get(filename);
 
-    if (fileInfo) {
-        if (typeof fileInfo === 'string') {
-            filename = fileInfo;
+            if (pluginObj) {
+                result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+                if (result) {
+                    return result;
+                }
+                try {
+                    if (pluginObj.use) {
+                        pluginObj.use.call(this.context, pluginObj);
+                    }
+                }
+                catch (e) {
+                    e.message = e.message || 'Error during @plugin call';
+                    return new LessError(e, imports, filename);
+                }
+                return pluginObj;
+            }
         }
-        else {
-            filename = fileInfo.filename;
+        localModule = {
+            exports: {},
+            pluginManager,
+            fileInfo
+        };
+        registry = functionRegistry.create();
+
+        const registerPlugin = obj => {
+            pluginObj = obj;
+        };
+
+        try {
+            loader = new Function('module', 'require', 'registerPlugin', 'functions', 'tree', 'less', 'fileInfo', contents);
+            loader(localModule, this.require(filename), registerPlugin, registry, this.less.tree, this.less, fileInfo);
+        }
+        catch (e) {
+            return new LessError(e, imports, filename);
         }
-    }
-    var shortname = (new this.less.FileManager()).extractUrlParts(filename).filename;
 
-    if (filename) {
-        pluginObj = pluginManager.get(filename);
+        if (!pluginObj) {
+            pluginObj = localModule.exports;
+        }
+        pluginObj = this.validatePlugin(pluginObj, filename, shortname);
+
+        if (pluginObj instanceof LessError) {
+            return pluginObj;
+        }
 
         if (pluginObj) {
+            pluginObj.imports = imports;
+            pluginObj.filename = filename;
+
+            // For < 3.x (or unspecified minVersion) - setOptions() before install()
+            if (!pluginObj.minVersion || this.compareVersion('3.0.0', pluginObj.minVersion) < 0) {
+                result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+
+                if (result) {
+                    return result;
+                }
+            }
+
+            // Run on first load
+            pluginManager.addPlugin(pluginObj, fileInfo.filename, registry);
+            pluginObj.functions = registry.getLocalFunctions();
+
+            // Need to call setOptions again because the pluginObj might have functions
             result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
             if (result) {
                 return result;
             }
+
+            // Run every @plugin call
             try {
                 if (pluginObj.use) {
                     pluginObj.use.call(this.context, pluginObj);
@@ -47,143 +109,79 @@ AbstractPluginLoader.prototype.evalPlugin = function(contents, context, imports,
                 e.message = e.message || 'Error during @plugin call';
                 return new LessError(e, imports, filename);
             }
-            return pluginObj;
-        }
-    }
-    localModule = {
-        exports: {},
-        pluginManager: pluginManager,
-        fileInfo: fileInfo
-    };
-    registry = functionRegistry.create();
-
-    var registerPlugin = function(obj) {
-        pluginObj = obj;
-    };
-
-    try {
-        loader = new Function('module', 'require', 'registerPlugin', 'functions', 'tree', 'less', 'fileInfo', contents);
-        loader(localModule, this.require(filename), registerPlugin, registry, this.less.tree, this.less, fileInfo);
-    }
-    catch (e) {
-        return new LessError(e, imports, filename);
-    }
 
-    if (!pluginObj) {
-        pluginObj = localModule.exports;
-    }
-    pluginObj = this.validatePlugin(pluginObj, filename, shortname);
+        }
+        else {
+            return new LessError({ message: 'Not a valid plugin' }, imports, filename);
+        }
 
-    if (pluginObj instanceof LessError) {
         return pluginObj;
     }
 
-    if (pluginObj) {
-        pluginObj.imports = imports;
-        pluginObj.filename = filename;
-
-        // For < 3.x (or unspecified minVersion) - setOptions() before install()
-        if (!pluginObj.minVersion || this.compareVersion('3.0.0', pluginObj.minVersion) < 0) {
-            result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
-
-            if (result) {
-                return result;
-            }
-        }
-
-        // Run on first load
-        pluginManager.addPlugin(pluginObj, fileInfo.filename, registry);
-        pluginObj.functions = registry.getLocalFunctions();
-
-        // Need to call setOptions again because the pluginObj might have functions
-        result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
-        if (result) {
-            return result;
+    trySetOptions(plugin, filename, name, options) {
+        if (options && !plugin.setOptions) {
+            return new LessError({
+                message: `Options have been provided but the plugin ${name} does not support any options.`
+            });
         }
-
-        // Run every @plugin call
         try {
-            if (pluginObj.use) {
-                pluginObj.use.call(this.context, pluginObj);
-            }
+            plugin.setOptions && plugin.setOptions(options);
         }
         catch (e) {
-            e.message = e.message || 'Error during @plugin call';
-            return new LessError(e, imports, filename);
+            return new LessError(e);
         }
-
-    }
-    else {
-        return new LessError({ message: 'Not a valid plugin' }, imports, filename);
     }
 
-    return pluginObj;
-
-};
+    validatePlugin(plugin, filename, name) {
+        if (plugin) {
+            // support plugins being a function
+            // so that the plugin can be more usable programmatically
+            if (typeof plugin === 'function') {
+                plugin = new plugin();
+            }
 
-AbstractPluginLoader.prototype.trySetOptions = function(plugin, filename, name, options) {
-    if (options && !plugin.setOptions) {
-        return new LessError({
-            message: 'Options have been provided but the plugin ' +
-                name + ' does not support any options.'
-        });
-    }
-    try {
-        plugin.setOptions && plugin.setOptions(options);
-    }
-    catch (e) {
-        return new LessError(e);
-    }
-};
-
-AbstractPluginLoader.prototype.validatePlugin = function(plugin, filename, name) {
-    if (plugin) {
-        // support plugins being a function
-        // so that the plugin can be more usable programmatically
-        if (typeof plugin === 'function') {
-            plugin = new plugin();
-        }
-
-        if (plugin.minVersion) {
-            if (this.compareVersion(plugin.minVersion, this.less.version) < 0) {
-                return new LessError({
-                    message: 'Plugin ' + name + ' requires version ' +
-                        this.versionToString(plugin.minVersion)
-                });
+            if (plugin.minVersion) {
+                if (this.compareVersion(plugin.minVersion, this.less.version) < 0) {
+                    return new LessError({
+                        message: `Plugin ${name} requires version ${this.versionToString(plugin.minVersion)}`
+                    });
+                }
             }
+            return plugin;
         }
-        return plugin;
+        return null;
     }
-    return null;
-};
 
-AbstractPluginLoader.prototype.compareVersion = function(aVersion, bVersion) {
-    if (typeof aVersion === 'string') {
-        aVersion = aVersion.match(/^(\d+)\.?(\d+)?\.?(\d+)?/);
-        aVersion.shift();
-    }
-    for (var i = 0; i < aVersion.length; i++) {
-        if (aVersion[i] !== bVersion[i]) {
-            return parseInt(aVersion[i]) > parseInt(bVersion[i]) ? -1 : 1;
+    compareVersion(aVersion, bVersion) {
+        if (typeof aVersion === 'string') {
+            aVersion = aVersion.match(/^(\d+)\.?(\d+)?\.?(\d+)?/);
+            aVersion.shift();
+        }
+        for (let i = 0; i < aVersion.length; i++) {
+            if (aVersion[i] !== bVersion[i]) {
+                return parseInt(aVersion[i]) > parseInt(bVersion[i]) ? -1 : 1;
+            }
         }
+        return 0;
     }
-    return 0;
-};
-AbstractPluginLoader.prototype.versionToString = function(version) {
-    var versionString = '';
-    for (var i = 0; i < version.length; i++) {
-        versionString += (versionString ? '.' : '') + version[i];
+
+    versionToString(version) {
+        let versionString = '';
+        for (let i = 0; i < version.length; i++) {
+            versionString += (versionString ? '.' : '') + version[i];
+        }
+        return versionString;
     }
-    return versionString;
-};
-AbstractPluginLoader.prototype.printUsage = function(plugins) {
-    for (var i = 0; i < plugins.length; i++) {
-        var plugin = plugins[i];
-        if (plugin.printUsage) {
-            plugin.printUsage();
+
+    printUsage(plugins) {
+        for (let i = 0; i < plugins.length; i++) {
+            const plugin = plugins[i];
+            if (plugin.printUsage) {
+                plugin.printUsage();
+            }
         }
     }
-};
+}
 
-module.exports = AbstractPluginLoader;
+export default AbstractPluginLoader;
 

package/lib/less/environment/environment-api.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
     /**
      * Converts a string to a base 64 string
      * @param str

package/lib/less/environment/environment.js

@@ -3,54 +3,57 @@
  *       environment, file managers, and plugin manager
  */
 
-var logger = require('../logger');
-var environment = function(externalEnvironment, fileManagers) {
-    this.fileManagers = fileManagers || [];
-    externalEnvironment = externalEnvironment || {};
-
-    var optionalFunctions = ['encodeBase64', 'mimeLookup', 'charsetLookup', 'getSourceMapGenerator'],
-        requiredFunctions = [],
-        functions = requiredFunctions.concat(optionalFunctions);
-
-    for (var i = 0; i < functions.length; i++) {
-        var propName = functions[i],
-            environmentFunc = externalEnvironment[propName];
-        if (environmentFunc) {
-            this[propName] = environmentFunc.bind(externalEnvironment);
-        } else if (i < requiredFunctions.length) {
-            this.warn('missing required function in environment - ' + propName);
+import logger from '../logger';
+
+class environment {
+    constructor(externalEnvironment, fileManagers) {
+        this.fileManagers = fileManagers || [];
+        externalEnvironment = externalEnvironment || {};
+
+        const optionalFunctions = ['encodeBase64', 'mimeLookup', 'charsetLookup', 'getSourceMapGenerator'];
+        const requiredFunctions = [];
+        const functions = requiredFunctions.concat(optionalFunctions);
+
+        for (let i = 0; i < functions.length; i++) {
+            const propName = functions[i];
+            const environmentFunc = externalEnvironment[propName];
+            if (environmentFunc) {
+                this[propName] = environmentFunc.bind(externalEnvironment);
+            } else if (i < requiredFunctions.length) {
+                this.warn(`missing required function in environment - ${propName}`);
+            }
         }
     }
-};
 
-environment.prototype.getFileManager = function (filename, currentDirectory, options, environment, isSync) {
+    getFileManager(filename, currentDirectory, options, environment, isSync) {
 
-    if (!filename) {
-        logger.warn('getFileManager called with no filename.. Please report this issue. continuing.');
-    }
-    if (currentDirectory == null) {
-        logger.warn('getFileManager called with null directory.. Please report this issue. continuing.');
-    }
+        if (!filename) {
+            logger.warn('getFileManager called with no filename.. Please report this issue. continuing.');
+        }
+        if (currentDirectory == null) {
+            logger.warn('getFileManager called with null directory.. Please report this issue. continuing.');
+        }
 
-    var fileManagers = this.fileManagers;
-    if (options.pluginManager) {
-        fileManagers = [].concat(fileManagers).concat(options.pluginManager.getFileManagers());
-    }
-    for (var i = fileManagers.length - 1; i >= 0 ; i--) {
-        var fileManager = fileManagers[i];
-        if (fileManager[isSync ? 'supportsSync' : 'supports'](filename, currentDirectory, options, environment)) {
-            return fileManager;
+        let fileManagers = this.fileManagers;
+        if (options.pluginManager) {
+            fileManagers = [].concat(fileManagers).concat(options.pluginManager.getFileManagers());
+        }
+        for (let i = fileManagers.length - 1; i >= 0 ; i--) {
+            const fileManager = fileManagers[i];
+            if (fileManager[isSync ? 'supportsSync' : 'supports'](filename, currentDirectory, options, environment)) {
+                return fileManager;
+            }
         }
+        return null;
     }
-    return null;
-};
 
-environment.prototype.addFileManager = function (fileManager) {
-    this.fileManagers.push(fileManager);
-};
+    addFileManager(fileManager) {
+        this.fileManagers.push(fileManager);
+    }
 
-environment.prototype.clearFileManagers = function () {
-    this.fileManagers = [];
-};
+    clearFileManagers() {
+        this.fileManagers = [];
+    }
+}
 
-module.exports = environment;
+export default environment;