less 2.3.1 → 2.4.0

package/dist/less.js

@@ -1,5 +1,5 @@
 /*!
- * Less - Leaner CSS v2.3.1
+ * Less - Leaner CSS v2.4.0
  * http://lesscss.org
  *
  * Copyright (c) 2009-2015, Alexis Sellier <self@cloudhead.net>
@@ -85,7 +85,7 @@ if (options.onReady) {
         }
     );
 }
-},{"./add-default-options":1,"./index":7,"promise/polyfill.js":undefined}],3:[function(require,module,exports){
+},{"./add-default-options":1,"./index":7,"promise/polyfill.js":"promise/polyfill.js"}],3:[function(require,module,exports){
 var utils = require("./utils");
 module.exports = {
     createCSS: function (document, styles, sheet) {
@@ -158,13 +158,13 @@ module.exports = function(window, options, logger) {
     var cache = null;
     if (options.env !== 'development') {
         try {
-            cache = (typeof(window.localStorage) === 'undefined') ? null : window.localStorage;
+            cache = (typeof window.localStorage === 'undefined') ? null : window.localStorage;
         } catch (_) {}
     }
     return {
         setCSS: function(path, lastModified, styles) {
             if (cache) {
-                logger.info('saving ' + path+ ' to cache.');
+                logger.info('saving ' + path + ' to cache.');
                 try {
                     cache.setItem(path, styles);
                     cache.setItem(path + ':timestamp', lastModified);
@@ -365,120 +365,120 @@ module.exports = function(window, less, options) {
 
 module.exports = function(options, logger) {
 
-var AbstractFileManager = require("../less/environment/abstract-file-manager.js");
+    var AbstractFileManager = require("../less/environment/abstract-file-manager.js");
 
-var fileCache = {};
+    var fileCache = {};
 
-//TODOS - move log somewhere. pathDiff and doing something similar in node. use pathDiff in the other browser file for the initial load
+    //TODOS - move log somewhere. pathDiff and doing something similar in node. use pathDiff in the other browser file for the initial load
 
-function getXMLHttpRequest() {
-    if (window.XMLHttpRequest && (window.location.protocol !== "file:" || !("ActiveXObject" in window))) {
-        return new XMLHttpRequest();
-    } else {
-        try {
-            /*global ActiveXObject */
-            return new ActiveXObject("Microsoft.XMLHTTP");
-        } catch (e) {
-            logger.error("browser doesn't support AJAX.");
-            return null;
+    function getXMLHttpRequest() {
+        if (window.XMLHttpRequest && (window.location.protocol !== "file:" || !("ActiveXObject" in window))) {
+            return new XMLHttpRequest();
+        } else {
+            try {
+                /*global ActiveXObject */
+                return new ActiveXObject("Microsoft.XMLHTTP");
+            } catch (e) {
+                logger.error("browser doesn't support AJAX.");
+                return null;
+            }
         }
     }
-}
 
-var FileManager = function() {
-};
+    var FileManager = function() {
+    };
 
-FileManager.prototype = new AbstractFileManager();
+    FileManager.prototype = new AbstractFileManager();
 
-FileManager.prototype.alwaysMakePathsAbsolute = function alwaysMakePathsAbsolute() {
-    return true;
-};
-FileManager.prototype.join = function join(basePath, laterPath) {
-    if (!basePath) {
-        return laterPath;
-    }
-    return this.extractUrlParts(laterPath, basePath).path;
-};
-FileManager.prototype.doXHR = function doXHR(url, type, callback, errback) {
+    FileManager.prototype.alwaysMakePathsAbsolute = function alwaysMakePathsAbsolute() {
+        return true;
+    };
+    FileManager.prototype.join = function join(basePath, laterPath) {
+        if (!basePath) {
+            return laterPath;
+        }
+        return this.extractUrlParts(laterPath, basePath).path;
+    };
+    FileManager.prototype.doXHR = function doXHR(url, type, callback, errback) {
 
-    var xhr = getXMLHttpRequest();
-    var async = options.isFileProtocol ? options.fileAsync : options.async;
+        var xhr = getXMLHttpRequest();
+        var async = options.isFileProtocol ? options.fileAsync : options.async;
 
-    if (typeof(xhr.overrideMimeType) === 'function') {
-        xhr.overrideMimeType('text/css');
-    }
-    logger.debug("XHR: Getting '" + url + "'");
-    xhr.open('GET', url, async);
-    xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
-    xhr.send(null);
+        if (typeof xhr.overrideMimeType === 'function') {
+            xhr.overrideMimeType('text/css');
+        }
+        logger.debug("XHR: Getting '" + url + "'");
+        xhr.open('GET', url, async);
+        xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
+        xhr.send(null);
 
-    function handleResponse(xhr, callback, errback) {
-        if (xhr.status >= 200 && xhr.status < 300) {
-            callback(xhr.responseText,
-                xhr.getResponseHeader("Last-Modified"));
-        } else if (typeof(errback) === 'function') {
-            errback(xhr.status, url);
+        function handleResponse(xhr, callback, errback) {
+            if (xhr.status >= 200 && xhr.status < 300) {
+                callback(xhr.responseText,
+                    xhr.getResponseHeader("Last-Modified"));
+            } else if (typeof errback === 'function') {
+                errback(xhr.status, url);
+            }
         }
-    }
 
-    if (options.isFileProtocol && !options.fileAsync) {
-        if (xhr.status === 0 || (xhr.status >= 200 && xhr.status < 300)) {
-            callback(xhr.responseText);
+        if (options.isFileProtocol && !options.fileAsync) {
+            if (xhr.status === 0 || (xhr.status >= 200 && xhr.status < 300)) {
+                callback(xhr.responseText);
+            } else {
+                errback(xhr.status, url);
+            }
+        } else if (async) {
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState == 4) {
+                    handleResponse(xhr, callback, errback);
+                }
+            };
         } else {
-            errback(xhr.status, url);
+            handleResponse(xhr, callback, errback);
         }
-    } else if (async) {
-        xhr.onreadystatechange = function () {
-            if (xhr.readyState == 4) {
-                handleResponse(xhr, callback, errback);
-            }
-        };
-    } else {
-        handleResponse(xhr, callback, errback);
-    }
-};
-FileManager.prototype.supports = function(filename, currentDirectory, options, environment) {
-    return true;
-};
+    };
+    FileManager.prototype.supports = function(filename, currentDirectory, options, environment) {
+        return true;
+    };
 
-FileManager.prototype.clearFileCache = function() {
-    fileCache = {};
-};
+    FileManager.prototype.clearFileCache = function() {
+        fileCache = {};
+    };
 
-FileManager.prototype.loadFile = function loadFile(filename, currentDirectory, options, environment, callback) {
-    if (currentDirectory && !this.isPathAbsolute(filename)) {
-        filename = currentDirectory + filename;
-    }
+    FileManager.prototype.loadFile = function loadFile(filename, currentDirectory, options, environment, callback) {
+        if (currentDirectory && !this.isPathAbsolute(filename)) {
+            filename = currentDirectory + filename;
+        }
 
-    options = options || {};
+        options = options || {};
 
-    // sheet may be set to the stylesheet for the initial load or a collection of properties including
-    // some context variables for imports
-    var hrefParts = this.extractUrlParts(filename, window.location.href);
-    var href      = hrefParts.url;
+        // sheet may be set to the stylesheet for the initial load or a collection of properties including
+        // some context variables for imports
+        var hrefParts = this.extractUrlParts(filename, window.location.href);
+        var href      = hrefParts.url;
 
-    if (options.useFileCache && fileCache[href]) {
-        try {
-            var lessText = fileCache[href];
-            callback(null, { contents: lessText, filename: href, webInfo: { lastModified: new Date() }});
-        } catch (e) {
-            callback({filename: href, message: "Error loading file " + href + " error was " + e.message});
+        if (options.useFileCache && fileCache[href]) {
+            try {
+                var lessText = fileCache[href];
+                callback(null, { contents: lessText, filename: href, webInfo: { lastModified: new Date() }});
+            } catch (e) {
+                callback({filename: href, message: "Error loading file " + href + " error was " + e.message});
+            }
+            return;
         }
-        return;
-    }
 
-    this.doXHR(href, options.mime, function doXHRCallback(data, lastModified) {
-        // per file cache
-        fileCache[href] = data;
+        this.doXHR(href, options.mime, function doXHRCallback(data, lastModified) {
+            // per file cache
+            fileCache[href] = data;
 
-        // Use remote copy (re-parse)
-        callback(null, { contents: data, filename: href, webInfo: { lastModified: lastModified }});
-    }, function doXHRError(status, url) {
-        callback({ type: 'File', message: "'" + url + "' wasn't found (" + status + ")", href: href });
-    });
-};
+            // Use remote copy (re-parse)
+            callback(null, { contents: data, filename: href, webInfo: { lastModified: lastModified }});
+        }, function doXHRError(status, url) {
+            callback({ type: 'File', message: "'" + url + "' wasn't found (" + status + ")", href: href });
+        });
+    };
 
-return FileManager;
+    return FileManager;
 };
 
 },{"../less/environment/abstract-file-manager.js":14}],7:[function(require,module,exports){
@@ -490,252 +490,252 @@ var addDataAttr = require("./utils").addDataAttr,
     browser = require("./browser");
 
 module.exports = function(window, options) {
-var document = window.document;
-var less = require('../less')();
-module.exports = less;
-less.options = options;
-var environment = less.environment,
-    FileManager = require("./file-manager")(options, less.logger),
-    fileManager = new FileManager();
-environment.addFileManager(fileManager);
-less.FileManager = FileManager;
-
-require("./log-listener")(less, options);
-var errors = require("./error-reporting")(window, less, options);
-var cache = less.cache = options.cache || require("./cache")(window, options, less.logger);
-
-//Setup user functions
-if (options.functions) {
-    less.functions.functionRegistry.addMultiple(options.functions);
-}
+    var document = window.document;
+    var less = require('../less')();
+    //module.exports = less;
+    less.options = options;
+    var environment = less.environment,
+        FileManager = require("./file-manager")(options, less.logger),
+        fileManager = new FileManager();
+    environment.addFileManager(fileManager);
+    less.FileManager = FileManager;
 
-var typePattern = /^text\/(x-)?less$/;
+    require("./log-listener")(less, options);
+    var errors = require("./error-reporting")(window, less, options);
+    var cache = less.cache = options.cache || require("./cache")(window, options, less.logger);
 
-function postProcessCSS(styles) {
-    if (options.postProcessor && typeof options.postProcessor === 'function') {
-        styles = options.postProcessor.call(styles, styles) || styles;
+    //Setup user functions
+    if (options.functions) {
+        less.functions.functionRegistry.addMultiple(options.functions);
     }
-    return styles;
-}
 
-function clone(obj) {
-    var cloned = {};
-    for(var prop in obj) {
-        if (obj.hasOwnProperty(prop)) {
-            cloned[prop] = obj[prop];
+    var typePattern = /^text\/(x-)?less$/;
+
+    function postProcessCSS(styles) {
+        if (options.postProcessor && typeof options.postProcessor === 'function') {
+            styles = options.postProcessor.call(styles, styles) || styles;
         }
+        return styles;
     }
-    return cloned;
-}
-
-// only really needed for phantom
-function bind(func, thisArg) {
-    var curryArgs = Array.prototype.slice.call(arguments, 2);
-    return function() {
-        var args = curryArgs.concat(Array.prototype.slice.call(arguments, 0));
-        return func.apply(thisArg, args);
-    };
-}
 
-function loadStyles(modifyVars) {
-    var styles = document.getElementsByTagName('style'),
-        style;
+    function clone(obj) {
+        var cloned = {};
+        for (var prop in obj) {
+            if (obj.hasOwnProperty(prop)) {
+                cloned[prop] = obj[prop];
+            }
+        }
+        return cloned;
+    }
 
-    for (var i = 0; i < styles.length; i++) {
-        style = styles[i];
-        if (style.type.match(typePattern)) {
-            var instanceOptions = clone(options);
-            instanceOptions.modifyVars = modifyVars;
-            var lessText = style.innerHTML || '';
-            instanceOptions.filename = document.location.href.replace(/#.*$/, '');
+    // only really needed for phantom
+    function bind(func, thisArg) {
+        var curryArgs = Array.prototype.slice.call(arguments, 2);
+        return function() {
+            var args = curryArgs.concat(Array.prototype.slice.call(arguments, 0));
+            return func.apply(thisArg, args);
+        };
+    }
 
-            /*jshint loopfunc:true */
-            // use closure to store current style
-            less.render(lessText, instanceOptions,
-                    bind(function(style, e, result) {
-                        if (e) {
-                            errors.add(e, "inline");
-                        } else {
-                            style.type = 'text/css';
-                            if (style.styleSheet) {
-                                style.styleSheet.cssText = result.css;
+    function loadStyles(modifyVars) {
+        var styles = document.getElementsByTagName('style'),
+            style;
+
+        for (var i = 0; i < styles.length; i++) {
+            style = styles[i];
+            if (style.type.match(typePattern)) {
+                var instanceOptions = clone(options);
+                instanceOptions.modifyVars = modifyVars;
+                var lessText = style.innerHTML || '';
+                instanceOptions.filename = document.location.href.replace(/#.*$/, '');
+
+                /*jshint loopfunc:true */
+                // use closure to store current style
+                less.render(lessText, instanceOptions,
+                        bind(function(style, e, result) {
+                            if (e) {
+                                errors.add(e, "inline");
                             } else {
-                                style.innerHTML = result.css;
+                                style.type = 'text/css';
+                                if (style.styleSheet) {
+                                    style.styleSheet.cssText = result.css;
+                                } else {
+                                    style.innerHTML = result.css;
+                                }
                             }
-                        }
-                    }, null, style));
+                        }, null, style));
+            }
         }
     }
-}
 
-function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
+    function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
 
-    var instanceOptions = clone(options);
-    addDataAttr(instanceOptions, sheet);
-    instanceOptions.mime = sheet.type;
+        var instanceOptions = clone(options);
+        addDataAttr(instanceOptions, sheet);
+        instanceOptions.mime = sheet.type;
 
-    if (modifyVars) {
-        instanceOptions.modifyVars = modifyVars;
-    }
+        if (modifyVars) {
+            instanceOptions.modifyVars = modifyVars;
+        }
 
-    function loadInitialFileCallback(loadedFile) {
+        function loadInitialFileCallback(loadedFile) {
 
-        var data = loadedFile.contents,
-            path = loadedFile.filename,
-            webInfo = loadedFile.webInfo;
+            var data = loadedFile.contents,
+                path = loadedFile.filename,
+                webInfo = loadedFile.webInfo;
 
-        var newFileInfo = {
-            currentDirectory: fileManager.getPath(path),
-            filename: path,
-            rootFilename: path,
-            relativeUrls: instanceOptions.relativeUrls};
-
-        newFileInfo.entryPath = newFileInfo.currentDirectory;
-        newFileInfo.rootpath = instanceOptions.rootpath || newFileInfo.currentDirectory;
-
-        if (webInfo) {
-            webInfo.remaining = remaining;
-
-            if (!instanceOptions.modifyVars) {
-                var css = cache.getCSS(path, webInfo);
-                if (!reload && css) {
-                    webInfo.local = true;
-                    callback(null, css, data, sheet, webInfo, path);
-                    return;
+            var newFileInfo = {
+                currentDirectory: fileManager.getPath(path),
+                filename: path,
+                rootFilename: path,
+                relativeUrls: instanceOptions.relativeUrls};
+
+            newFileInfo.entryPath = newFileInfo.currentDirectory;
+            newFileInfo.rootpath = instanceOptions.rootpath || newFileInfo.currentDirectory;
+
+            if (webInfo) {
+                webInfo.remaining = remaining;
+
+                if (!instanceOptions.modifyVars) {
+                    var css = cache.getCSS(path, webInfo);
+                    if (!reload && css) {
+                        webInfo.local = true;
+                        callback(null, css, data, sheet, webInfo, path);
+                        return;
+                    }
                 }
             }
-        }
 
-        //TODO add tests around how this behaves when reloading
-        errors.remove(path);
+            //TODO add tests around how this behaves when reloading
+            errors.remove(path);
 
-        instanceOptions.rootFileInfo = newFileInfo;
-        less.render(data, instanceOptions, function(e, result) {
+            instanceOptions.rootFileInfo = newFileInfo;
+            less.render(data, instanceOptions, function(e, result) {
+                if (e) {
+                    e.href = path;
+                    callback(e);
+                } else {
+                    result.css = postProcessCSS(result.css);
+                    if (!instanceOptions.modifyVars) {
+                        cache.setCSS(sheet.href, webInfo.lastModified, result.css);
+                    }
+                    callback(null, result.css, data, sheet, webInfo, path);
+                }
+            });
+        }
+
+        fileManager.loadFile(sheet.href, null, instanceOptions, environment, function(e, loadedFile) {
             if (e) {
-                e.href = path;
                 callback(e);
-            } else {
-                result.css = postProcessCSS(result.css);
-                if (!instanceOptions.modifyVars) {
-                    cache.setCSS(sheet.href, webInfo.lastModified, result.css);
-                }
-                callback(null, result.css, data, sheet, webInfo, path);
+                return;
             }
+            loadInitialFileCallback(loadedFile);
         });
     }
 
-    fileManager.loadFile(sheet.href, null, instanceOptions, environment, function(e, loadedFile) {
-        if (e) {
-            callback(e);
-            return;
+    function loadStyleSheets(callback, reload, modifyVars) {
+        for (var i = 0; i < less.sheets.length; i++) {
+            loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
         }
-        loadInitialFileCallback(loadedFile);
-    });
-}
-
-function loadStyleSheets(callback, reload, modifyVars) {
-    for (var i = 0; i < less.sheets.length; i++) {
-        loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
     }
-}
 
-function initRunningMode(){
-    if (less.env === 'development') {
-        less.watchTimer = setInterval(function () {
-            if (less.watchMode) {
-                fileManager.clearFileCache();
-                loadStyleSheets(function (e, css, _, sheet, webInfo) {
-                    if (e) {
-                        errors.add(e, e.href || sheet.href);
-                    } else if (css) {
-                        browser.createCSS(window.document, css, sheet);
-                    }
-                });
-            }
-        }, options.poll);
-    }
-}
-
-//
-// Watch mode
-//
-less.watch   = function () {
-    if (!less.watchMode ){
-        less.env = 'development';
-         initRunningMode();
+    function initRunningMode() {
+        if (less.env === 'development') {
+            less.watchTimer = setInterval(function () {
+                if (less.watchMode) {
+                    fileManager.clearFileCache();
+                    loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                        if (e) {
+                            errors.add(e, e.href || sheet.href);
+                        } else if (css) {
+                            browser.createCSS(window.document, css, sheet);
+                        }
+                    });
+                }
+            }, options.poll);
+        }
     }
-    this.watchMode = true;
-    return true;
-};
 
-less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
+    //
+    // Watch mode
+    //
+    less.watch   = function () {
+        if (!less.watchMode ) {
+            less.env = 'development';
+            initRunningMode();
+        }
+        this.watchMode = true;
+        return true;
+    };
 
-//
-// Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
-//
-less.registerStylesheets = function() {
-    return new Promise(function(resolve, reject) {
-        var links = document.getElementsByTagName('link');
-        less.sheets = [];
+    less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
 
-        for (var i = 0; i < links.length; i++) {
-            if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
-                (links[i].type.match(typePattern)))) {
-                less.sheets.push(links[i]);
+    //
+    // Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
+    //
+    less.registerStylesheets = function() {
+        return new Promise(function(resolve, reject) {
+            var links = document.getElementsByTagName('link');
+            less.sheets = [];
+
+            for (var i = 0; i < links.length; i++) {
+                if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
+                    (links[i].type.match(typePattern)))) {
+                    less.sheets.push(links[i]);
+                }
             }
-        }
 
-        resolve();
-    });
-};
+            resolve();
+        });
+    };
 
-//
-// With this function, it's possible to alter variables and re-render
-// CSS without reloading less-files
-//
-less.modifyVars = function(record) {
-    return less.refresh(true, record, false);
-};
+    //
+    // With this function, it's possible to alter variables and re-render
+    // CSS without reloading less-files
+    //
+    less.modifyVars = function(record) {
+        return less.refresh(true, record, false);
+    };
 
-less.refresh = function (reload, modifyVars, clearFileCache) {
-    if ((reload || clearFileCache) && clearFileCache !== false) {
-        fileManager.clearFileCache();
-    }
-    return new Promise(function (resolve, reject) {
-        var startTime, endTime, totalMilliseconds;
-        startTime = endTime = new Date();
+    less.refresh = function (reload, modifyVars, clearFileCache) {
+        if ((reload || clearFileCache) && clearFileCache !== false) {
+            fileManager.clearFileCache();
+        }
+        return new Promise(function (resolve, reject) {
+            var startTime, endTime, totalMilliseconds;
+            startTime = endTime = new Date();
 
-        loadStyleSheets(function (e, css, _, sheet, webInfo) {
-            if (e) {
-                errors.add(e, e.href || sheet.href);
-                reject(e);
-                return;
-            }
-            if (webInfo.local) {
-                less.logger.info("loading " + sheet.href + " from cache.");
-            } else {
-                less.logger.info("rendered " + sheet.href + " successfully.");
-            }
-            browser.createCSS(window.document, css, sheet);
-            less.logger.info("css for " + sheet.href + " generated in " + (new Date() - endTime) + 'ms');
-            if (webInfo.remaining === 0) {
-                totalMilliseconds = new Date() - startTime;
-                less.logger.info("less has finished. css generated in " + totalMilliseconds + 'ms');
-                resolve({
-                    startTime: startTime,
-                    endTime: endTime,
-                    totalMilliseconds: totalMilliseconds,
-                    sheets: less.sheets.length
-                });
-            }
-            endTime = new Date();
-        }, reload, modifyVars);
+            loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                if (e) {
+                    errors.add(e, e.href || sheet.href);
+                    reject(e);
+                    return;
+                }
+                if (webInfo.local) {
+                    less.logger.info("loading " + sheet.href + " from cache.");
+                } else {
+                    less.logger.info("rendered " + sheet.href + " successfully.");
+                }
+                browser.createCSS(window.document, css, sheet);
+                less.logger.info("css for " + sheet.href + " generated in " + (new Date() - endTime) + 'ms');
+                if (webInfo.remaining === 0) {
+                    totalMilliseconds = new Date() - startTime;
+                    less.logger.info("less has finished. css generated in " + totalMilliseconds + 'ms');
+                    resolve({
+                        startTime: startTime,
+                        endTime: endTime,
+                        totalMilliseconds: totalMilliseconds,
+                        sheets: less.sheets.length
+                    });
+                }
+                endTime = new Date();
+            }, reload, modifyVars);
 
-        loadStyles(modifyVars);
-    });
-};
+            loadStyles(modifyVars);
+        });
+    };
 
-less.refreshStyles = loadStyles;
+    less.refreshStyles = loadStyles;
     return less;
 };
 
@@ -753,7 +753,7 @@ module.exports = function(less, options) {
     // 1 - Errors
     // 0 - None
     // Defaults to 2
-    options.logLevel = typeof(options.logLevel) !== 'undefined' ? options.logLevel : (options.env === 'development' ?  logLevel_info : logLevel_error);
+    options.logLevel = typeof options.logLevel !== 'undefined' ? options.logLevel : (options.env === 'development' ?  logLevel_info : logLevel_error);
 
     if (!options.loggers) {
         options.loggers = [{
@@ -779,7 +779,7 @@ module.exports = function(less, options) {
             }
         }];
     }
-    for(var i = 0; i < options.loggers.length; i++) {
+    for (var i = 0; i < options.loggers.length; i++) {
         less.logger.addListener(options.loggers[i]);
     }
 };
@@ -787,12 +787,12 @@ module.exports = function(less, options) {
 },{}],9:[function(require,module,exports){
 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)
+        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) {
@@ -817,7 +817,7 @@ module.exports = contexts;
 var copyFromOriginal = function copyFromOriginal(original, destination, propertiesToCopy) {
     if (!original) { return; }
 
-    for(var i = 0; i < propertiesToCopy.length; i++) {
+    for (var i = 0; i < propertiesToCopy.length; i++) {
         if (original.hasOwnProperty(propertiesToCopy[i])) {
             destination[propertiesToCopy[i]] = original[propertiesToCopy[i]];
         }
@@ -890,7 +890,7 @@ contexts.Eval.prototype.isMathOn = function () {
 };
 
 contexts.Eval.prototype.isPathRelative = function (path) {
-    return !/^(?:[a-z-]+:|\/)/i.test(path);
+    return !/^(?:[a-z-]+:|\/|#)/i.test(path);
 };
 
 contexts.Eval.prototype.normalizePath = function( path ) {
@@ -1133,7 +1133,7 @@ abstractFileManager.prototype.alwaysMakePathsAbsolute = function() {
 };
 
 abstractFileManager.prototype.isPathAbsolute = function(filename) {
-    return (/^(?:[a-z-]+:|\/|\\)/i).test(filename);
+    return (/^(?:[a-z-]+:|\/|\\|#)/i).test(filename);
 };
 
 abstractFileManager.prototype.join = function(basePath, laterPath) {
@@ -1152,15 +1152,15 @@ abstractFileManager.prototype.pathDiff = function pathDiff(url, baseUrl) {
         return "";
     }
     max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
-    for(i = 0; i < max; i++) {
+    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++) {
+    for (i = 0; i < baseUrlDirectories.length - 1; i++) {
         diff += "../";
     }
-    for(i = 0; i < urlDirectories.length - 1; i++) {
+    for (i = 0; i < urlDirectories.length - 1; i++) {
         diff += urlDirectories[i] + "/";
     }
     return diff;
@@ -1197,14 +1197,14 @@ abstractFileManager.prototype.extractUrlParts = function extractUrlParts(url, ba
         directories = urlParts[3].replace(/\\/g, "/").split("/");
 
         // extract out . before .. so .. doesn't absorb a non-directory
-        for(i = 0; i < directories.length; i++) {
+        for (i = 0; i < directories.length; i++) {
             if (directories[i] === ".") {
                 directories.splice(i, 1);
                 i -= 1;
             }
         }
 
-        for(i = 0; i < directories.length; i++) {
+        for (i = 0; i < directories.length; i++) {
             if (directories[i] === ".." && i > 0) {
                 directories.splice(i - 1, 2);
                 i -= 2;
@@ -1232,7 +1232,7 @@ var environment = function(externalEnvironment, fileManagers) {
         requiredFunctions = [],
         functions = requiredFunctions.concat(optionalFunctions);
 
-    for(var i = 0; i < functions.length; i++) {
+    for (var i = 0; i < functions.length; i++) {
         var propName = functions[i],
             environmentFunc = externalEnvironment[propName];
         if (environmentFunc) {
@@ -1256,7 +1256,7 @@ environment.prototype.getFileManager = function (filename, currentDirectory, opt
     if (options.pluginManager) {
         fileManagers = [].concat(fileManagers).concat(options.pluginManager.getFileManagers());
     }
-    for(var i = fileManagers.length - 1; i >= 0 ; i--) {
+    for (var i = fileManagers.length - 1; i >= 0 ; i--) {
         var fileManager = fileManagers[i];
         if (fileManager[isSync ? "supportsSync" : "supports"](filename, currentDirectory, options, environment)) {
             return fileManager;
@@ -1368,7 +1368,7 @@ function hsla(color) {
 function number(n) {
     if (n instanceof Dimension) {
         return parseFloat(n.unit.is('%') ? n.value / 100 : n.value);
-    } else if (typeof(n) === 'number') {
+    } else if (typeof n === 'number') {
         return n;
     } else {
         throw {
@@ -1399,10 +1399,18 @@ colorFunctions = {
     hsla: function (h, s, l, a) {
         function hue(h) {
             h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
-            if      (h * 6 < 1) { return m1 + (m2 - m1) * h * 6; }
-            else if (h * 2 < 1) { return m2; }
-            else if (h * 3 < 2) { return m1 + (m2 - m1) * (2 / 3 - h) * 6; }
-            else                { return m1; }
+            if (h * 6 < 1) {
+                return m1 + (m2 - m1) * h * 6;
+            }
+            else if (h * 2 < 1) {
+                return m2;
+            }
+            else if (h * 3 < 2) {
+                return m1 + (m2 - m1) * (2 / 3 - h) * 6;
+            }
+            else {
+                return m1;
+            }
         }
 
         h = (number(h) % 360) / 360;
@@ -1843,7 +1851,7 @@ for (var f in mathFunctions) {
 }
 
 mathFunctions.round = function (n, f) {
-    var fraction = typeof(f) === "undefined" ? 0 : f.value;
+    var fraction = typeof f === "undefined" ? 0 : f.value;
     return _math(function(num) { return num.toFixed(fraction); }, null, n);
 };
 
@@ -1866,7 +1874,7 @@ var minMax = function (isMin, args) {
     for (i = 0; i < args.length; i++) {
         current = args[i];
         if (!(current instanceof Dimension)) {
-            if(Array.isArray(args[i].value)) {
+            if (Array.isArray(args[i].value)) {
                 Array.prototype.push.apply(args, Array.prototype.slice.call(args[i].value));
             }
             continue;
@@ -1877,7 +1885,7 @@ var minMax = function (isMin, args) {
         unitClone = unit !== "" && unitClone === undefined ? current.unit.toString() : unitClone;
         j = values[""] !== undefined && unit !== "" && unit === unitStatic ? values[""] : values[unit];
         if (j === undefined) {
-            if(unitStatic !== undefined && unit !== unitStatic) {
+            if (unitStatic !== undefined && unit !== unitStatic) {
                 throw{ type: "Argument", message: "incompatible types" };
             }
             values[unit] = order.length;
@@ -2058,7 +2066,7 @@ var Keyword = require("../tree/keyword"),
     functionRegistry = require("./function-registry");
 
 var isa = function (n, Type) {
-    return (n instanceof Type) ? Keyword.True : Keyword.False;
+        return (n instanceof Type) ? Keyword.True : Keyword.False;
     },
     isunit = function (n, unit) {
         if (unit === undefined) {
@@ -2069,6 +2077,19 @@ var isa = function (n, Type) {
             throw { type: "Argument", message: "Second argument to isunit should be a unit or a string." };
         }
         return (n instanceof Dimension) && n.unit.is(unit) ? Keyword.True : Keyword.False;
+    },
+    getItemsFromNode = function(node) {
+        // handle non-array values as an array of length 1
+        // return 'undefined' if index is invalid
+        var items = Array.isArray(node.value) ?
+            node.value : Array(node);
+
+        return items.filter(function(item) {
+            if (item.type === "Comment") {
+                return false;
+            }
+            return true;
+        });
     };
 functionRegistry.addMultiple({
     isruleset: function (n) {
@@ -2100,7 +2121,7 @@ functionRegistry.addMultiple({
     },
     isunit: isunit,
     unit: function (val, unit) {
-        if(!(val instanceof Dimension)) {
+        if (!(val instanceof Dimension)) {
             throw { type: "Argument",
                 message: "the first argument to unit must be a number" +
                     (val instanceof Operation ? ". Have you forgotten parenthesis?" : "") };
@@ -2121,14 +2142,11 @@ functionRegistry.addMultiple({
     },
     extract: function(values, index) {
         index = index.value - 1; // (1-based index)
-        // handle non-array values as an array of length 1
-        // return 'undefined' if index is invalid
-        return Array.isArray(values.value) ?
-            values.value[index] : Array(values)[index];
+
+        return getItemsFromNode(values)[index];
     },
     length: function(values) {
-        var n = Array.isArray(values.value) ? values.value.length : 1;
-        return new Dimension(n);
+        return new Dimension(getItemsFromNode(values).length);
     }
 });
 
@@ -2176,12 +2194,12 @@ module.exports = function(environment) {
 
             var importedEqualsRoot = fullPath === importManager.rootFilename;
             if (importOptions.optional && e) {
-            callback(null, {rules:[]}, false, null);
+                callback(null, {rules:[]}, false, null);
             }
             else {
-            importManager.files[fullPath] = root;
-            if (e && !importManager.error) { importManager.error = e; }
-            callback(e, root, importedEqualsRoot, fullPath);
+                importManager.files[fullPath] = root;
+                if (e && !importManager.error) { importManager.error = e; }
+                callback(e, root, importedEqualsRoot, fullPath);
             }
         };
 
@@ -2216,7 +2234,7 @@ module.exports = function(environment) {
             // - If path of imported file is '../mixins.less' and rootpath is 'less/',
             //   then rootpath should become 'less/../'
             newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
-            if(newFileInfo.relativeUrls) {
+            if (newFileInfo.relativeUrls) {
                 newFileInfo.rootpath = fileManager.join(
                     (importManager.context.rootpath || ""),
                     fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
@@ -2265,7 +2283,7 @@ module.exports = function(environment, fileManagers) {
     var SourceMapOutput, SourceMapBuilder, ParseTree, ImportManager, Environment;
 
     var less = {
-        version: [2, 3, 1],
+        version: [2, 4, 0],
         data: require('./data'),
         tree: require('./tree'),
         Environment: (Environment = require("./environment/environment")),
@@ -2311,7 +2329,7 @@ var LessError = module.exports = function LessError(e, importManager, currentFil
         this.type = e.type || 'Syntax';
         this.filename = filename;
         this.index = e.index;
-        this.line = typeof(line) === 'number' ? line + 1 : null;
+        this.line = typeof line === 'number' ? line + 1 : null;
         this.callLine = callLine + 1;
         this.callExtract = lines[callLine];
         this.column = col;
@@ -2353,7 +2371,7 @@ module.exports = {
         this._listeners.push(listener);
     },
     removeListener: function(listener) {
-        for(var i = 0; i < this._listeners.length; i++) {
+        for (var i = 0; i < this._listeners.length; i++) {
             if (this._listeners[i] === listener) {
                 this._listeners.splice(i, 1);
                 return;
@@ -2361,7 +2379,7 @@ module.exports = {
         }
     },
     _fireEvent: function(type, msg) {
-        for(var i = 0; i < this._listeners.length; i++) {
+        for (var i = 0; i < this._listeners.length; i++) {
             var logFunction = this._listeners[i][type];
             if (logFunction) {
                 logFunction(msg);
@@ -2377,64 +2395,64 @@ var LessError = require('./less-error'),
     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);
-    }
+    var ParseTree = function(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.");
+    ParseTree.prototype.toCSS = function(options) {
+        var evaldRoot, result = {}, 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 {
+            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.");
+            }
 
-        if (options.sourceMap) {
-            sourceMapBuilder = new SourceMapBuilder(options.sourceMap);
-            result.css = sourceMapBuilder.toCSS(evaldRoot, toCSSOptions, this.imports);
-        } else {
-            result.css = evaldRoot.toCSS(toCSSOptions);
+            var toCSSOptions = {
+                compress: 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) {
+            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.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 (var file in this.imports.files) {
+            if (this.imports.files.hasOwnProperty(file) && file !== this.imports.rootFilename) {
+                result.imports.push(file);
+            }
         }
-    }
-    return result;
-};
-return ParseTree;
+        return result;
+    };
+    return ParseTree;
 };
 
 },{"./less-error":30,"./logger":31,"./transform-tree":41}],33:[function(require,module,exports){
-var PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise,
+var PromiseConstructor,
     contexts = require("./contexts"),
     Parser = require('./parser/parser'),
     PluginManager = require('./plugin-manager');
@@ -2443,12 +2461,15 @@ module.exports = function(environment, ParseTree, ImportManager) {
     var parse = function (input, options, callback) {
         options = options || {};
 
-        if (typeof(options) === 'function') {
+        if (typeof options === 'function') {
             callback = options;
             options = {};
         }
 
         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) {
@@ -2690,7 +2711,7 @@ module.exports = function() {
         //
         skipWhitespace(length);
 
-        if(typeof(match) === 'string') {
+        if (typeof match === 'string') {
             return match;
         } else {
             return match.length === 1 ? match[0] : match;
@@ -2709,7 +2730,7 @@ module.exports = function() {
         }
 
         skipWhitespace(m[0].length);
-        if(typeof m === "string") {
+        if (typeof m === "string") {
             return m;
         }
 
@@ -2802,7 +2823,7 @@ module.exports = function() {
     // Same as $(), but don't change the state of the parser,
     // just return the match.
     parserInput.peek = function(tok) {
-        if (typeof(tok) === 'string') {
+        if (typeof tok === 'string') {
             return input.charAt(parserInput.i) === tok;
         } else {
             return tok.test(current);
@@ -2924,7 +2945,7 @@ var Parser = function Parser(context, imports, fileInfo) {
         if (result) {
             return result;
         }
-        error(msg || (typeof(arg) === 'string' ? "expected '" + arg + "' got '" + parserInput.currentChar() + "'"
+        error(msg || (typeof arg === 'string' ? "expected '" + arg + "' got '" + parserInput.currentChar() + "'"
                                                : "unexpected token"));
     }
 
@@ -2969,17 +2990,26 @@ var Parser = function Parser(context, imports, fileInfo) {
         // @param [additionalData] An optional map which can contains vars - a map (key, value) of variables to apply
         //
         parse: function (str, callback, additionalData) {
-            var root, error = null, globalVars, modifyVars, preText = "";
+            var root, error = null, globalVars, modifyVars, ignored, preText = "";
 
             globalVars = (additionalData && additionalData.globalVars) ? Parser.serializeVars(additionalData.globalVars) + '\n' : '';
             modifyVars = (additionalData && additionalData.modifyVars) ? '\n' + Parser.serializeVars(additionalData.modifyVars) : '';
 
+            if (context.pluginManager) {
+                var preProcessors = context.pluginManager.getPreProcessors();
+                for (var i = 0; i < preProcessors.length; i++) {
+                    str = preProcessors[i].process(str, { context: context, imports: imports, fileInfo: fileInfo });
+                }
+            }
+
             if (globalVars || (additionalData && additionalData.banner)) {
                 preText = ((additionalData && additionalData.banner) ? additionalData.banner : "") + globalVars;
-                imports.contentsIgnoredChars[fileInfo.filename] = preText.length;
+                ignored = imports.contentsIgnoredChars;
+                ignored[fileInfo.filename] = ignored[fileInfo.filename] || 0;
+                ignored[fileInfo.filename] += preText.length;
             }
 
-            str = str.replace(/\r\n/g, '\n');
+            str = str.replace(/\r\n?/g, '\n');
             // Remove potential UTF Byte Order Mark
             str = preText + str.replace(/^\uFEFF/, '') + modifyVars;
             imports.contents[fileInfo.filename] = str;
@@ -3110,7 +3140,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                 while (true)
                 {
-                    while(true) {
+                    while (true) {
                         node = this.comment();
                         if (!node) { break; }
                         root.push(node);
@@ -3209,7 +3239,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                     if (nameLC === 'alpha') {
                         alpha = parsers.alpha();
-                        if(alpha) {
+                        if (alpha) {
                             return alpha;
                         }
                     }
@@ -3424,8 +3454,14 @@ var Parser = function Parser(context, imports, fileInfo) {
                     elements = null;
                     while (! (option = parserInput.$re(/^(all)(?=\s*(\)|,))/))) {
                         e = this.element();
-                        if (!e) { break; }
-                        if (elements) { elements.push(e); } else { elements = [ e ]; }
+                        if (!e) {
+                            break;
+                        }
+                        if (elements) {
+                            elements.push(e);
+                        } else {
+                            elements = [ e ];
+                        }
                     }
 
                     option = option && option[1];
@@ -3433,9 +3469,12 @@ var Parser = function Parser(context, imports, fileInfo) {
                         error("Missing target selector for :extend().");
                     }
                     extend = new(tree.Extend)(new(tree.Selector)(elements), option, index);
-                    if (extendList) { extendList.push(extend); } else { extendList = [ extend ]; }
-
-                } while(parserInput.$char(","));
+                    if (extendList) {
+                        extendList.push(extend);
+                    } else {
+                        extendList = [ extend ];
+                    }
+                } while (parserInput.$char(","));
 
                 expect(/^\)/);
 
@@ -3483,7 +3522,11 @@ var Parser = function Parser(context, imports, fileInfo) {
                             break;
                         }
                         elem = new(tree.Element)(c, e, elemIndex, fileInfo);
-                        if (elements) { elements.push(elem); } else { elements = [ elem ]; }
+                        if (elements) {
+                            elements.push(elem);
+                        } else {
+                            elements = [ elem ];
+                        }
                         c = parserInput.$char('>');
                     }
 
@@ -3824,11 +3867,19 @@ var Parser = function Parser(context, imports, fileInfo) {
                     } else if (condition) {
                         error("CSS guard can only be used at the end of selector");
                     } else if (extendList) {
-                        if (allExtends) { allExtends = allExtends.concat(extendList); } else { allExtends = extendList; }
+                        if (allExtends) {
+                            allExtends = allExtends.concat(extendList);
+                        } else {
+                            allExtends = extendList;
+                        }
                     } else {
                         if (allExtends) { error("Extend can only be used at the end of selector"); }
                         c = parserInput.currentChar();
-                        if (elements) { elements.push(e); } else { elements = [ e ]; }
+                        if (elements) {
+                            elements.push(e);
+                        } else {
+                            elements = [ e ];
+                        }
                         e = null;
                     }
                     if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') {
@@ -3903,7 +3954,11 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (!s) {
                         break;
                     }
-                    if (selectors) { selectors.push(s); } else { selectors = [ s ]; }
+                    if (selectors) {
+                        selectors.push(s);
+                    } else {
+                        selectors = [ s ];
+                    }
                     parserInput.commentStore.length = 0;
                     if (s.condition && selectors.length > 1) {
                         error("Guards are only currently allowed on a single selector.");
@@ -4040,11 +4095,11 @@ var Parser = function Parser(context, imports, fileInfo) {
                             case "css":
                                 optionName = "less";
                                 value = false;
-                            break;
+                                break;
                             case "once":
                                 optionName = "multiple";
                                 value = false;
-                            break;
+                                break;
                         }
                         options[optionName] = value;
                         if (! parserInput.$char(',')) { break; }
@@ -4255,7 +4310,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                         expressions.push(e);
                         if (! parserInput.$char(',')) { break; }
                     }
-                } while(e);
+                } while (e);
 
                 if (expressions.length > 0) {
                     return new(tree.Value)(expressions);
@@ -4505,6 +4560,7 @@ module.exports = Parser;
 var PluginManager = function(less) {
     this.less = less;
     this.visitors = [];
+    this.preProcessors = [];
     this.postProcessors = [];
     this.installedPlugins = [];
     this.fileManagers = [];
@@ -4515,7 +4571,7 @@ var PluginManager = function(less) {
  */
 PluginManager.prototype.addPlugins = function(plugins) {
     if (plugins) {
-        for(var i = 0;i < plugins.length; i++) {
+        for (var i = 0; i < plugins.length; i++) {
             this.addPlugin(plugins[i]);
         }
     }
@@ -4536,6 +4592,20 @@ PluginManager.prototype.addPlugin = function(plugin) {
 PluginManager.prototype.addVisitor = function(visitor) {
     this.visitors.push(visitor);
 };
+/**
+ * Adds a pre processor object
+ * @param {object} preProcessor
+ * @param {number} priority - guidelines 1 = before import, 1000 = import, 2000 = after import
+ */
+PluginManager.prototype.addPreProcessor = function(preProcessor, priority) {
+    var indexToInsertAt;
+    for (indexToInsertAt = 0; indexToInsertAt < this.preProcessors.length; indexToInsertAt++) {
+        if (this.preProcessors[indexToInsertAt].priority >= priority) {
+            break;
+        }
+    }
+    this.preProcessors.splice(indexToInsertAt, 0, {preProcessor: preProcessor, priority: priority});
+};
 /**
  * Adds a post processor object
  * @param {object} postProcessor
@@ -4543,7 +4613,7 @@ PluginManager.prototype.addVisitor = function(visitor) {
  */
 PluginManager.prototype.addPostProcessor = function(postProcessor, priority) {
     var indexToInsertAt;
-    for(indexToInsertAt = 0; indexToInsertAt < this.postProcessors.length; indexToInsertAt++) {
+    for (indexToInsertAt = 0; indexToInsertAt < this.postProcessors.length; indexToInsertAt++) {
         if (this.postProcessors[indexToInsertAt].priority >= priority) {
             break;
         }
@@ -4557,6 +4627,18 @@ PluginManager.prototype.addPostProcessor = function(postProcessor, priority) {
 PluginManager.prototype.addFileManager = function(manager) {
     this.fileManagers.push(manager);
 };
+/**
+ *
+ * @returns {Array}
+ * @private
+ */
+PluginManager.prototype.getPreProcessors = function() {
+    var preProcessors = [];
+    for (var i = 0; i < this.preProcessors.length; i++) {
+        preProcessors.push(this.preProcessors[i].preProcessor);
+    }
+    return preProcessors;
+};
 /**
  *
  * @returns {Array}
@@ -4564,7 +4646,7 @@ PluginManager.prototype.addFileManager = function(manager) {
  */
 PluginManager.prototype.getPostProcessors = function() {
     var postProcessors = [];
-    for(var i = 0; i < this.postProcessors.length; i++) {
+    for (var i = 0; i < this.postProcessors.length; i++) {
         postProcessors.push(this.postProcessors[i].postProcessor);
     }
     return postProcessors;
@@ -4588,16 +4670,19 @@ PluginManager.prototype.getFileManagers = function() {
 module.exports = PluginManager;
 
 },{}],38:[function(require,module,exports){
-var PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise;
+var PromiseConstructor;
 
 module.exports = function(environment, ParseTree, ImportManager) {
     var render = function (input, options, callback) {
-        if (typeof(options) === 'function') {
+        if (typeof options === 'function') {
             callback = options;
             options = {};
         }
 
         if (!callback) {
+            if (!PromiseConstructor) {
+                PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise;
+            }
             var self = this;
             return new PromiseConstructor(function (resolve, reject) {
                 render.call(self, input, options, function(err, output) {
@@ -4660,8 +4745,12 @@ module.exports = function (SourceMapOutput, environment) {
     };
 
     SourceMapBuilder.prototype.getCSSAppendage = function() {
+
         var sourceMapURL = this.sourceMapURL;
         if (this.options.sourceMapFileInline) {
+            if (this.sourceMap === undefined) {
+                return "";
+            }
             sourceMapURL = "data:application/json;base64," + environment.encodeBase64(this.sourceMap);
         }
 
@@ -4731,7 +4820,7 @@ module.exports = function (environment) {
         if (this._sourceMapBasepath && filename.indexOf(this._sourceMapBasepath) === 0) {
             filename = filename.substring(this._sourceMapBasepath.length);
             if (filename.charAt(0) === '\\' || filename.charAt(0) === '/') {
-               filename = filename.substring(1);
+                filename = filename.substring(1);
             }
         }
         return (this._sourceMapRootpath || "") + filename;
@@ -4775,7 +4864,7 @@ module.exports = function (environment) {
                     original: { line: sourceLines.length, column: sourceColumns.length},
                     source: this.normalizeFilename(fileInfo.filename)});
             } else {
-                for(i = 0; i < lines.length; i++) {
+                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)});
@@ -4801,7 +4890,7 @@ module.exports = function (environment) {
         this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });
 
         if (this._outputSourceFiles) {
-            for(var filename in this._contentsMap) {
+            for (var filename in this._contentsMap) {
                 if (this._contentsMap.hasOwnProperty(filename))
                 {
                     var source = this._contentsMap[filename];
@@ -4859,7 +4948,7 @@ module.exports = function(root, options) {
     //     ])
     //   )
     //
-    if (typeof(variables) === 'object' && !Array.isArray(variables)) {
+    if (typeof variables === 'object' && !Array.isArray(variables)) {
         variables = Object.keys(variables).map(function (k) {
             var value = variables[k];
 
@@ -4883,7 +4972,7 @@ module.exports = function(root, options) {
 
     if (options.pluginManager) {
         var pluginVisitors = options.pluginManager.getVisitors();
-        for(i = 0; i < pluginVisitors.length; i++) {
+        for (i = 0; i < pluginVisitors.length; i++) {
             var pluginVisitor = pluginVisitors[i];
             if (pluginVisitor.isPreEvalVisitor) {
                 preEvalVisitors.push(pluginVisitor);
@@ -4897,13 +4986,13 @@ module.exports = function(root, options) {
         }
     }
 
-    for(i = 0; i < preEvalVisitors.length; i++) {
+    for (i = 0; i < preEvalVisitors.length; i++) {
         preEvalVisitors[i].run(root);
     }
 
     evaldRoot = root.eval(evalEnv);
 
-    for(i = 0; i < visitors.length; i++) {
+    for (i = 0; i < visitors.length; i++) {
         visitors[i].run(evaldRoot);
     }
 
@@ -4948,7 +5037,7 @@ var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike)
     this.index = index;
     this.mapLines = mapLines;
     this.currentFileInfo = currentFileInfo;
-    this.rulesetLike = (typeof rulesetLike === 'undefined')? false : rulesetLike;
+    this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
 };
 Anonymous.prototype = new Node();
 Anonymous.prototype.type = "Anonymous";
@@ -5077,7 +5166,7 @@ Call.prototype.eval = function (context) {
 Call.prototype.genCSS = function (context, output) {
     output.add(this.name + "(", this.currentFileInfo, this.index);
 
-    for(var i = 0; i < this.args.length; i++) {
+    for (var i = 0; i < this.args.length; i++) {
         this.args[i].genCSS(context, output);
         if (i + 1 < this.args.length) {
             output.add(", ");
@@ -5113,7 +5202,7 @@ var Color = function (rgb, a) {
             return parseInt(c + c, 16);
         });
     }
-    this.alpha = typeof(a) === 'number' ? a : 1;
+    this.alpha = typeof a === 'number' ? a : 1;
 };
 
 Color.prototype = new Node();
@@ -5240,7 +5329,7 @@ Color.prototype.toHSV = function () {
     if (max === min) {
         h = 0;
     } else {
-        switch(max){
+        switch(max) {
             case r: h = (g - b) / d + (g < b ? 6 : 0); break;
             case g: h = (b - r) / d + 2; break;
             case b: h = (r - g) / d + 4; break;
@@ -5354,10 +5443,14 @@ Condition.prototype.eval = function (context) {
             case 'or':  return a || b;
             default:
                 switch (Node.compare(a, b)) {
-                    case -1: return op === '<' || op === '=<' || op === '<=';
-                    case  0: return op === '=' || op === '>=' || op === '=<' || op === '<=';
-                    case  1: return op === '>' || op === '>=';
-                        default: return false;
+                    case -1:
+                        return op === '<' || op === '=<' || op === '<=';
+                    case 0:
+                        return op === '=' || op === '>=' || op === '=<' || op === '<=';
+                    case 1:
+                        return op === '>' || op === '>=';
+                    default:
+                        return false;
                 }
         }
     })(this.op, this.lvalue.eval(context), this.rvalue.eval(context));
@@ -5502,9 +5595,9 @@ Dimension.prototype.operate = function (context, op, other) {
         } else {
             other = other.convertTo(this.unit.usedUnits());
 
-            if(context.strictUnits && other.unit.toString() !== unit.toString()) {
-              throw new Error("Incompatible units. Change the units or use the unit function. Bad units: '" + unit.toString() +
-                "' and '" + other.unit.toString() + "'.");
+            if (context.strictUnits && other.unit.toString() !== unit.toString()) {
+                throw new Error("Incompatible units. Change the units or use the unit function. Bad units: '" + unit.toString() +
+                    "' and '" + other.unit.toString() + "'.");
             }
 
             value = this._operate(context, op, this.value, other.value);
@@ -5548,7 +5641,7 @@ Dimension.prototype.convertTo = function (conversions) {
         i, groupName, group, targetUnit, derivedConversions = {}, applyUnit;
 
     if (typeof conversions === 'string') {
-        for(i in unitConversions) {
+        for (i in unitConversions) {
             if (unitConversions[i].hasOwnProperty(conversions)) {
                 derivedConversions = {};
                 derivedConversions[i] = conversions;
@@ -5720,7 +5813,7 @@ var Element = function (combinator, value, index, currentFileInfo) {
     this.combinator = combinator instanceof Combinator ?
                       combinator : new Combinator(combinator);
 
-    if (typeof(value) === 'string') {
+    if (typeof value === 'string') {
         this.value = value.trim();
     } else if (value) {
         this.value = value;
@@ -5810,7 +5903,7 @@ Expression.prototype.eval = function (context) {
     return returnValue;
 };
 Expression.prototype.genCSS = function (context, output) {
-    for(var i = 0; i < this.value.length; i++) {
+    for (var i = 0; i < this.value.length; i++) {
         this.value[i].genCSS(context, output);
         if (i + 1 < this.value.length) {
             output.add(" ");
@@ -5838,11 +5931,11 @@ var Extend = function Extend(selector, option, index) {
         case "all":
             this.allowBefore = true;
             this.allowAfter = true;
-        break;
+            break;
         default:
             this.allowBefore = false;
             this.allowAfter = false;
-        break;
+            break;
     }
 };
 Extend.next_id = 0;
@@ -5863,7 +5956,7 @@ Extend.prototype.findSelfSelectors = function (selectors) {
         i,
         selectorElements;
 
-    for(i = 0; i < selectors.length; i++) {
+    for (i = 0; i < selectors.length; i++) {
         selectorElements = selectors[i].elements;
         // duplicate the logic in genCSS function inside the selector node.
         // future TODO - move both logics into the selector joiner visitor
@@ -6079,9 +6172,9 @@ JavaScript.prototype.type = "JavaScript";
 JavaScript.prototype.eval = function(context) {
     var result = this.evaluateJavaScript(this.expression, context);
 
-    if (typeof(result) === 'number') {
+    if (typeof result === 'number') {
         return new Dimension(result);
-    } else if (typeof(result) === 'string') {
+    } else if (typeof result === 'string') {
         return new Quoted('"' + result + '"', result, this.escaped, this.index);
     } else if (Array.isArray(result)) {
         return new Anonymous(result.join(', '));
@@ -6213,7 +6306,7 @@ Media.prototype.eval = function (context) {
     }
 
     var media = new Media(null, [], this.index, this.currentFileInfo);
-    if(this.debugInfo) {
+    if (this.debugInfo) {
         this.rules[0].debugInfo = this.debugInfo;
         media.debugInfo = this.debugInfo;
     }
@@ -6301,7 +6394,7 @@ Media.prototype.evalNested = function (context) {
             return fragment.toCSS ? fragment : new Anonymous(fragment);
         });
 
-        for(i = path.length - 1; i > 0; i--) {
+        for (i = path.length - 1; i > 0; i--) {
             path.splice(i, 0, new Anonymous("and"));
         }
 
@@ -6312,26 +6405,26 @@ Media.prototype.evalNested = function (context) {
     return new Ruleset([], []);
 };
 Media.prototype.permute = function (arr) {
-  if (arr.length === 0) {
-      return [];
-  } else if (arr.length === 1) {
-      return arr[0];
-  } else {
-      var result = [];
-      var rest = this.permute(arr.slice(1));
-      for (var i = 0; i < rest.length; i++) {
-          for (var j = 0; j < arr[0].length; j++) {
-              result.push([arr[0][j]].concat(rest[i]));
-          }
-      }
-      return result;
-  }
+    if (arr.length === 0) {
+        return [];
+    } else if (arr.length === 1) {
+        return arr[0];
+    } else {
+        var result = [];
+        var rest = this.permute(arr.slice(1));
+        for (var i = 0; i < rest.length; i++) {
+            for (var j = 0; j < arr[0].length; j++) {
+                result.push([arr[0][j]].concat(rest[i]));
+            }
+        }
+        return result;
+    }
 };
 Media.prototype.bubbleSelectors = function (selectors) {
-  if (!selectors) {
-      return;
-  }
-  this.rules = [new Ruleset(selectors.slice(0), [this.rules[0]])];
+    if (!selectors) {
+        return;
+    }
+    this.rules = [new Ruleset(selectors.slice(0), [this.rules[0]])];
 };
 module.exports = Media;
 
@@ -6369,7 +6462,7 @@ MixinCall.prototype.eval = function (context) {
         for (f = 0; f < 2; f++) {
             conditionResult[f] = true;
             defaultFunc.value(f);
-            for(p = 0; p < mixinPath.length && conditionResult[f]; p++) {
+            for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
                 namespace = mixinPath[p];
                 if (namespace.matchCondition) {
                     conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
@@ -6409,7 +6502,7 @@ MixinCall.prototype.eval = function (context) {
                 mixin = mixins[m].rule;
                 mixinPath = mixins[m].path;
                 isRecursive = false;
-                for(f = 0; f < context.frames.length; f++) {
+                for (f = 0; f < context.frames.length; f++) {
                     if ((!(mixin instanceof MixinDefinition)) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
                         isRecursive = true;
                         break;
@@ -6524,8 +6617,12 @@ var Definition = function (name, params, rules, condition, variadic, frames) {
     this.rules = rules;
     this._lookups = {};
     this.required = params.reduce(function (count, p) {
-        if (!p.name || (p.name && !p.value)) { return count + 1; }
-        else                                 { return count; }
+        if (!p.name || (p.name && !p.value)) {
+            return count + 1;
+        }
+        else {
+            return count;
+        }
     }, 0);
     this.frames = frames;
 };
@@ -6554,11 +6651,11 @@ Definition.prototype.evalParams = function (context, mixinEnv, args, evaldArgume
         args = args.slice(0);
         argsLength = args.length;
 
-        for(i = 0; i < argsLength; i++) {
+        for (i = 0; i < argsLength; i++) {
             arg = args[i];
             if (name = (arg && arg.name)) {
                 isNamedFound = false;
-                for(j = 0; j < params.length; j++) {
+                for (j = 0; j < params.length; j++) {
                     if (!evaldArguments[j] && name === params[j].name) {
                         evaldArguments[j] = arg.value.eval(context);
                         frame.prependRule(new Rule(name, arg.value.eval(context)));
@@ -6617,6 +6714,17 @@ Definition.prototype.evalParams = function (context, mixinEnv, args, evaldArgume
 
     return frame;
 };
+Definition.prototype.makeImportant = function() {
+    var rules = !this.rules ? this.rules : this.rules.map(function (r) {
+        if (r.makeImportant) {
+            return r.makeImportant(true);
+        } else {
+            return r;
+        }
+    });
+    var result = new Definition (this.name, this.params, rules, this.condition, this.variadic, this.frames);
+    return result;
+};
 Definition.prototype.eval = function (context) {
     return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || context.frames.slice(0));
 };
@@ -6634,7 +6742,7 @@ Definition.prototype.evalCall = function (context, args, important) {
     ruleset.originalRuleset = this;
     ruleset = ruleset.eval(new contexts.Eval(context, [this, frame].concat(mixinFrames)));
     if (important) {
-        ruleset = this.makeImportant.apply(ruleset);
+        ruleset = ruleset.makeImportant();
     }
     return ruleset;
 };
@@ -6653,10 +6761,16 @@ Definition.prototype.matchArgs = function (args, context) {
     var argsLength = (args && args.length) || 0, len;
 
     if (! this.variadic) {
-        if (argsLength < this.required)                               { return false; }
-        if (argsLength > this.params.length)                          { return false; }
+        if (argsLength < this.required) {
+            return false;
+        }
+        if (argsLength > this.params.length) {
+            return false;
+        }
     } else {
-        if (argsLength < (this.required - 1))                         { return false; }
+        if (argsLength < (this.required - 1)) {
+            return false;
+        }
     }
 
     len = Math.min(argsLength, this.arity);
@@ -6876,9 +6990,9 @@ Quoted.prototype.eval = function (context) {
     function iterativeReplace(value, regexp, replacementFnc) {
         var evaluatedValue = value;
         do {
-          value = evaluatedValue;
-          evaluatedValue = value.replace(regexp, replacementFnc);
-        } while  (value !== evaluatedValue);
+            value = evaluatedValue;
+            evaluatedValue = value.replace(regexp, replacementFnc);
+        } while (value !== evaluatedValue);
         return evaluatedValue;
     }
     value = iterativeReplace(value, /`([^`]+)`/g, javascriptReplacement);
@@ -6942,7 +7056,7 @@ Rule.prototype.eval = function (context) {
         // things faster (~10% for benchmark.less):
         name = (name.length === 1) && (name[0] instanceof Keyword) ?
                 name[0].value : evalName(context, name);
-            variable = false; // never treat expanded interpolation as new variable name
+        variable = false; // never treat expanded interpolation as new variable name
     }
     if (name === "font" && !context.strictMath) {
         strictMathBypass = true;
@@ -7068,7 +7182,7 @@ Ruleset.prototype.eval = function (context) {
     ruleset.firstRoot = this.firstRoot;
     ruleset.allowImports = this.allowImports;
 
-    if(this.debugInfo) {
+    if (this.debugInfo) {
         ruleset.debugInfo = this.debugInfo;
     }
 
@@ -7153,7 +7267,7 @@ Ruleset.prototype.eval = function (context) {
             if (rule.selectors[0].isJustParentSelector()) {
                 rsRules.splice(i--, 1);
 
-                for(var j = 0; j < rule.rules.length; j++) {
+                for (var j = 0; j < rule.rules.length; j++) {
                     subRule = rule.rules[j];
                     if (!(subRule instanceof Rule) || !subRule.variable) {
                         rsRules.splice(++i, 0, subRule);
@@ -7193,15 +7307,17 @@ Ruleset.prototype.evalImports = function(context) {
     }
 };
 Ruleset.prototype.makeImportant = function() {
-    this.rules = this.rules.map(function (r) {
+    var result = new Ruleset(this.selectors, this.rules.map(function (r) {
         if (r.makeImportant) {
             return r.makeImportant();
         } else {
             return r;
         }
-    });
-    return this;
-};Ruleset.prototype.matchArgs = function (args) {
+    }), this.strictImports);
+
+    return result;
+};
+Ruleset.prototype.matchArgs = function (args) {
     return !args || args.length === 0;
 };
 // lets you call a css selector with a guard
@@ -7234,7 +7350,7 @@ Ruleset.prototype.variables = function () {
             // guard against root being a string (in the case of inlined less)
             if (r.type === "Import" && r.root && r.root.variables) {
                 var vars = r.root.variables();
-                for(var name in vars) {
+                for (var name in vars) {
                     if (vars.hasOwnProperty(name)) {
                         hash[name] = vars[name];
                     }
@@ -7265,7 +7381,11 @@ Ruleset.prototype.rulesets = function () {
 };
 Ruleset.prototype.prependRule = function (rule) {
     var rules = this.rules;
-    if (rules) { rules.unshift(rule); } else { this.rules = [ rule ]; }
+    if (rules) {
+        rules.unshift(rule);
+    } else {
+        this.rules = [ rule ];
+    }
 };
 Ruleset.prototype.find = function (selector, self, filter) {
     self = self || this;
@@ -7280,13 +7400,13 @@ Ruleset.prototype.find = function (selector, self, filter) {
                 match = selector.match(rule.selectors[j]);
                 if (match) {
                     if (selector.elements.length > match) {
-                      if (!filter || filter(rule)) {
-                        foundMixins = rule.find(new Selector(selector.elements.slice(match)), self, filter);
-                        for (var i = 0; i < foundMixins.length; ++i) {
-                          foundMixins[i].path.push(rule);
+                        if (!filter || filter(rule)) {
+                            foundMixins = rule.find(new Selector(selector.elements.slice(match)), self, filter);
+                            for (var i = 0; i < foundMixins.length; ++i) {
+                                foundMixins[i].path.push(rule);
+                            }
+                            Array.prototype.push.apply(rules, foundMixins);
                         }
-                        Array.prototype.push.apply(rules, foundMixins);
-                      }
                     } else {
                         rules.push({ rule: rule, path: []});
                     }
@@ -7319,19 +7439,17 @@ Ruleset.prototype.genCSS = function (context, output) {
         sep;
 
     function isRulesetLikeNode(rule, root) {
-         // if it has nested rules, then it should be treated like a ruleset
-         // medias and comments do not have nested rules, but should be treated like rulesets anyway
-         // some directives and anonymous nodes are ruleset like, others are not
-         if (typeof rule.isRulesetLike === "boolean")
-         {
-             return rule.isRulesetLike;
-         } else if (typeof rule.isRulesetLike === "function")
-         {
-             return rule.isRulesetLike(root);
-         }
+        // if it has nested rules, then it should be treated like a ruleset
+        // medias and comments do not have nested rules, but should be treated like rulesets anyway
+        // some directives and anonymous nodes are ruleset like, others are not
+        if (typeof rule.isRulesetLike === "boolean") {
+            return rule.isRulesetLike;
+        } else if (typeof rule.isRulesetLike === "function") {
+            return rule.isRulesetLike(root);
+        }
 
-         //anything else is assumed to be a rule
-         return false;
+        //anything else is assumed to be a rule
+        return false;
     }
 
     for (i = 0; i < this.rules.length; i++) {
@@ -7508,7 +7626,7 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
         // }
         // == [[.a] [.c]] [[.b] [.c]]
         //
-        var i, j, k, currentElements, newSelectors, selectorsMultiplied, sel, el, hadParentSelector = false;
+        var i, j, k, currentElements, newSelectors, selectorsMultiplied, sel, el, hadParentSelector = false, length, lastSelector;
         function findNestedSelector(element) {
             var maybeSelector;
             if (element.value.type !== 'Paren') {
@@ -7602,8 +7720,11 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
         mergeElementsOnToSelectors(currentElements, newSelectors);
 
         for (i = 0; i < newSelectors.length; i++) {
-            if (newSelectors[i].length > 0) {
+            length = newSelectors[i].length;
+            if (length > 0) {
                 paths.push(newSelectors[i]);
+                lastSelector = newSelectors[i][length - 1];
+                newSelectors[i][length - 1] = lastSelector.createDerived(lastSelector.elements, inSelector.extendList);
             }
         }
 
@@ -7810,7 +7931,7 @@ Selector.prototype.genCSS = function (context, output) {
     }
     if (!this._css) {
         //TODO caching? speed comparison?
-        for(i = 0; i < this.elements.length; i++) {
+        for (i = 0; i < this.elements.length; i++) {
             element = this.elements[i];
             element.genCSS(context, output);
         }
@@ -7864,6 +7985,8 @@ Unit.prototype.genCSS = function (context, output) {
         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]);
     }
 };
 Unit.prototype.toString = function () {
@@ -8041,7 +8164,7 @@ Value.prototype.eval = function (context) {
 };
 Value.prototype.genCSS = function (context, output) {
     var i;
-    for(i = 0; i < this.value.length; i++) {
+    for (i = 0; i < this.value.length; i++) {
         this.value[i].genCSS(context, output);
         if (i + 1 < this.value.length) {
             output.add((context && context.compress) ? ',' : ', ');
@@ -8161,7 +8284,7 @@ ExtendFinderVisitor.prototype = {
 
         // get &:extend(.a); rules which apply to all selectors in this ruleset
         var rules = rulesetNode.rules, ruleCnt = rules ? rules.length : 0;
-        for(i = 0; i < ruleCnt; i++) {
+        for (i = 0; i < ruleCnt; i++) {
             if (rulesetNode.rules[i] instanceof tree.Extend) {
                 allSelectorsExtendList.push(rules[i]);
                 rulesetNode.extendOnEveryPath = true;
@@ -8171,7 +8294,7 @@ ExtendFinderVisitor.prototype = {
         // now find every selector and apply the extends that apply to all extends
         // and the ones which apply to an individual extend
         var paths = rulesetNode.paths;
-        for(i = 0; i < paths.length; i++) {
+        for (i = 0; i < paths.length; i++) {
             var selectorPath = paths[i],
                 selector = selectorPath[selectorPath.length - 1],
                 selExtendList = selector.extendList;
@@ -8185,7 +8308,7 @@ ExtendFinderVisitor.prototype = {
                 });
             }
 
-            for(j = 0; j < extendList.length; j++) {
+            for (j = 0; j < extendList.length; j++) {
                 this.foundExtends = true;
                 extend = extendList[j];
                 extend.findSelfSelectors(selectorPath);
@@ -8242,9 +8365,10 @@ ProcessExtendsVisitor.prototype = {
                 var selector = "_unknown_";
                 try {
                     selector = extend.selector.toCSS({});
-                }catch(_){}
+                }
+                catch(_) {}
 
-                if(!indicies[extend.index + ' ' + selector]) {
+                if (!indicies[extend.index + ' ' + selector]) {
                     indicies[extend.index + ' ' + selector] = true;
                     logger.warn("extend '" + selector + "' has no matches");
                 }
@@ -8271,14 +8395,14 @@ ProcessExtendsVisitor.prototype = {
         // and the second is the target.
         // the seperation into two lists allows us to process a subset of chains with a bigger set, as is the
         // case when processing media queries
-        for(extendIndex = 0; extendIndex < extendsList.length; extendIndex++){
-            for(targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++){
+        for (extendIndex = 0; extendIndex < extendsList.length; extendIndex++) {
+            for (targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++) {
 
                 extend = extendsList[extendIndex];
                 targetExtend = extendsListTarget[targetExtendIndex];
 
                 // look for circular references
-                if( extend.parent_ids.indexOf( targetExtend.object_id ) >= 0 ){ continue; }
+                if ( extend.parent_ids.indexOf( targetExtend.object_id ) >= 0 ) { continue; }
 
                 // find a match in the target extends self selector (the bit before :extend)
                 selectorPath = [targetExtend.selfSelectors[0]];
@@ -8362,8 +8486,8 @@ ProcessExtendsVisitor.prototype = {
 
         // look at each selector path in the ruleset, find any extend matches and then copy, find and replace
 
-        for(extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
-            for(pathIndex = 0; pathIndex < rulesetNode.paths.length; pathIndex++) {
+        for (extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
+            for (pathIndex = 0; pathIndex < rulesetNode.paths.length; pathIndex++) {
                 selectorPath = rulesetNode.paths[pathIndex];
 
                 // extending extends happens initially, before the main pass
@@ -8396,10 +8520,10 @@ ProcessExtendsVisitor.prototype = {
             potentialMatches = [], potentialMatch, matches = [];
 
         // loop through the haystack elements
-        for(haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
+        for (haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
             hackstackSelector = haystackSelectorPath[haystackSelectorIndex];
 
-            for(hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {
+            for (hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {
 
                 haystackElement = hackstackSelector.elements[hackstackElementIndex];
 
@@ -8409,7 +8533,7 @@ ProcessExtendsVisitor.prototype = {
                         initialCombinator: haystackElement.combinator});
                 }
 
-                for(i = 0; i < potentialMatches.length; i++) {
+                for (i = 0; i < potentialMatches.length; i++) {
                     potentialMatch = potentialMatches[i];
 
                     // selectors add " " onto the first element. When we use & it joins the selectors together, but if we don't
@@ -8479,7 +8603,7 @@ ProcessExtendsVisitor.prototype = {
             if (!(elementValue2 instanceof tree.Selector) || elementValue1.elements.length !== elementValue2.elements.length) {
                 return false;
             }
-            for(var i = 0; i  < elementValue1.elements.length; i++) {
+            for (var i = 0; i  < elementValue1.elements.length; i++) {
                 if (elementValue1.elements[i].combinator.value !== elementValue2.elements[i].combinator.value) {
                     if (i !== 0 || (elementValue1.elements[i].combinator.value || ' ') !== (elementValue2.elements[i].combinator.value || ' ')) {
                         return false;
@@ -8612,8 +8736,8 @@ ImportSequencer.prototype.addVariableImport = function(callback) {
 ImportSequencer.prototype.tryRun = function() {
     this._currentDepth++;
     try {
-        while(true) {
-            while(this.imports.length > 0) {
+        while (true) {
+            while (this.imports.length > 0) {
                 var importItem = this.imports[0];
                 if (!importItem.isReady) {
                     return;
@@ -8698,7 +8822,7 @@ ImportVisitor.prototype = {
 
         try {
             evaldImportNode = importNode.evalForImport(context);
-        } catch(e){
+        } catch(e) {
             if (!e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
             // attempt to eval properly and treat as css
             importNode.css = true;
@@ -8715,7 +8839,7 @@ ImportVisitor.prototype = {
             // try appending if we haven't determined if it is css or not
             var tryAppendLessExtension = evaldImportNode.css === undefined;
 
-            for(var i = 0; i < importParent.rules.length; i++) {
+            for (var i = 0; i < importParent.rules.length; i++) {
                 if (importParent.rules[i] === importNode) {
                     importParent.rules[i] = evaldImportNode;
                     break;
@@ -8978,7 +9102,7 @@ ToCSSVisitor.prototype = {
 
     checkPropertiesInRoot: function(rules) {
         var ruleNode;
-        for(var i = 0; i < rules.length; i++) {
+        for (var i = 0; i < rules.length; i++) {
             ruleNode = rules[i];
             if (ruleNode instanceof tree.Rule && !ruleNode.variable) {
                 throw { message: "properties must be inside selector blocks, they cannot be in the root.",
@@ -9000,7 +9124,7 @@ ToCSSVisitor.prototype = {
                         if (p[0].elements[0].combinator.value === ' ') {
                             p[0].elements[0].combinator = new(tree.Combinator)('');
                         }
-                        for(i = 0; i < p.length; i++) {
+                        for (i = 0; i < p.length; i++) {
                             if (p[i].getIsReferenced() && p[i].getIsOutput()) {
                                 return true;
                             }
@@ -9065,7 +9189,7 @@ ToCSSVisitor.prototype = {
         var ruleCache = {},
             ruleList, rule, i;
 
-        for(i = rules.length - 1; i >= 0 ; i--) {
+        for (i = rules.length - 1; i >= 0 ; i--) {
             rule = rules[i];
             if (rule instanceof tree.Rule) {
                 if (!ruleCache[rule.name]) {
@@ -9132,8 +9256,8 @@ ToCSSVisitor.prototype = {
                 var spacedGroups = [];
                 var lastSpacedGroup = [];
                 parts.map(function (p) {
-                if (p.merge === "+") {
-                    if (lastSpacedGroup.length > 0) {
+                    if (p.merge === "+") {
+                        if (lastSpacedGroup.length > 0) {
                             spacedGroups.push(toExpression(lastSpacedGroup));
                         }
                         lastSpacedGroup = [];
@@ -9307,69 +9431,39 @@ module.exports = Visitor;
 // shim for using process in browser
 
 var process = module.exports = {};
+var queue = [];
+var draining = false;
 
-process.nextTick = (function () {
-    var canSetImmediate = typeof window !== 'undefined'
-    && window.setImmediate;
-    var canMutationObserver = typeof window !== 'undefined'
-    && window.MutationObserver;
-    var canPost = typeof window !== 'undefined'
-    && window.postMessage && window.addEventListener
-    ;
-
-    if (canSetImmediate) {
-        return function (f) { return window.setImmediate(f) };
+function drainQueue() {
+    if (draining) {
+        return;
     }
-
-    var queue = [];
-
-    if (canMutationObserver) {
-        var hiddenDiv = document.createElement("div");
-        var observer = new MutationObserver(function () {
-            var queueList = queue.slice();
-            queue.length = 0;
-            queueList.forEach(function (fn) {
-                fn();
-            });
-        });
-
-        observer.observe(hiddenDiv, { attributes: true });
-
-        return function nextTick(fn) {
-            if (!queue.length) {
-                hiddenDiv.setAttribute('yes', 'no');
-            }
-            queue.push(fn);
-        };
+    draining = true;
+    var currentQueue;
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        var i = -1;
+        while (++i < len) {
+            currentQueue[i]();
+        }
+        len = queue.length;
     }
-
-    if (canPost) {
-        window.addEventListener('message', function (ev) {
-            var source = ev.source;
-            if ((source === window || source === null) && ev.data === 'process-tick') {
-                ev.stopPropagation();
-                if (queue.length > 0) {
-                    var fn = queue.shift();
-                    fn();
-                }
-            }
-        }, true);
-
-        return function nextTick(fn) {
-            queue.push(fn);
-            window.postMessage('process-tick', '*');
-        };
+    draining = false;
+}
+process.nextTick = function (fun) {
+    queue.push(fun);
+    if (!draining) {
+        setTimeout(drainQueue, 0);
     }
-
-    return function nextTick(fn) {
-        setTimeout(fn, 0);
-    };
-})();
+};
 
 process.title = 'browser';
 process.browser = true;
 process.env = {};
 process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
 
 function noop() {}
 
@@ -9390,223 +9484,224 @@ process.cwd = function () { return '/' };
 process.chdir = function (dir) {
     throw new Error('process.chdir is not supported');
 };
+process.umask = function() { return 0; };
 
 },{}],89:[function(require,module,exports){
-'use strict';
-
-var asap = require('asap')
-
-module.exports = Promise;
-function Promise(fn) {
-  if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new')
-  if (typeof fn !== 'function') throw new TypeError('not a function')
-  var state = null
-  var value = null
-  var deferreds = []
-  var self = this
-
-  this.then = function(onFulfilled, onRejected) {
-    return new self.constructor(function(resolve, reject) {
-      handle(new Handler(onFulfilled, onRejected, resolve, reject))
-    })
-  }
-
-  function handle(deferred) {
-    if (state === null) {
-      deferreds.push(deferred)
-      return
-    }
-    asap(function() {
-      var cb = state ? deferred.onFulfilled : deferred.onRejected
-      if (cb === null) {
-        (state ? deferred.resolve : deferred.reject)(value)
-        return
-      }
-      var ret
-      try {
-        ret = cb(value)
-      }
-      catch (e) {
-        deferred.reject(e)
-        return
-      }
-      deferred.resolve(ret)
-    })
-  }
-
-  function resolve(newValue) {
-    try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
-      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')
-      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
-        var then = newValue.then
-        if (typeof then === 'function') {
-          doResolve(then.bind(newValue), resolve, reject)
-          return
-        }
-      }
-      state = true
-      value = newValue
-      finale()
-    } catch (e) { reject(e) }
-  }
-
-  function reject(newValue) {
-    state = false
-    value = newValue
-    finale()
-  }
-
-  function finale() {
-    for (var i = 0, len = deferreds.length; i < len; i++)
-      handle(deferreds[i])
-    deferreds = null
-  }
-
-  doResolve(fn, resolve, reject)
-}
-
-
-function Handler(onFulfilled, onRejected, resolve, reject){
-  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
-  this.onRejected = typeof onRejected === 'function' ? onRejected : null
-  this.resolve = resolve
-  this.reject = reject
-}
-
-/**
- * Take a potentially misbehaving resolver function and make sure
- * onFulfilled and onRejected are only called once.
- *
- * Makes no guarantees about asynchrony.
- */
-function doResolve(fn, onFulfilled, onRejected) {
-  var done = false;
-  try {
-    fn(function (value) {
-      if (done) return
-      done = true
-      onFulfilled(value)
-    }, function (reason) {
-      if (done) return
-      done = true
-      onRejected(reason)
-    })
-  } catch (ex) {
-    if (done) return
-    done = true
-    onRejected(ex)
-  }
-}
+'use strict';
+
+var asap = require('asap')
+
+module.exports = Promise;
+function Promise(fn) {
+  if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new')
+  if (typeof fn !== 'function') throw new TypeError('not a function')
+  var state = null
+  var value = null
+  var deferreds = []
+  var self = this
+
+  this.then = function(onFulfilled, onRejected) {
+    return new self.constructor(function(resolve, reject) {
+      handle(new Handler(onFulfilled, onRejected, resolve, reject))
+    })
+  }
+
+  function handle(deferred) {
+    if (state === null) {
+      deferreds.push(deferred)
+      return
+    }
+    asap(function() {
+      var cb = state ? deferred.onFulfilled : deferred.onRejected
+      if (cb === null) {
+        (state ? deferred.resolve : deferred.reject)(value)
+        return
+      }
+      var ret
+      try {
+        ret = cb(value)
+      }
+      catch (e) {
+        deferred.reject(e)
+        return
+      }
+      deferred.resolve(ret)
+    })
+  }
+
+  function resolve(newValue) {
+    try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')
+      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+        var then = newValue.then
+        if (typeof then === 'function') {
+          doResolve(then.bind(newValue), resolve, reject)
+          return
+        }
+      }
+      state = true
+      value = newValue
+      finale()
+    } catch (e) { reject(e) }
+  }
+
+  function reject(newValue) {
+    state = false
+    value = newValue
+    finale()
+  }
+
+  function finale() {
+    for (var i = 0, len = deferreds.length; i < len; i++)
+      handle(deferreds[i])
+    deferreds = null
+  }
+
+  doResolve(fn, resolve, reject)
+}
+
+
+function Handler(onFulfilled, onRejected, resolve, reject){
+  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
+  this.onRejected = typeof onRejected === 'function' ? onRejected : null
+  this.resolve = resolve
+  this.reject = reject
+}
+
+/**
+ * Take a potentially misbehaving resolver function and make sure
+ * onFulfilled and onRejected are only called once.
+ *
+ * Makes no guarantees about asynchrony.
+ */
+function doResolve(fn, onFulfilled, onRejected) {
+  var done = false;
+  try {
+    fn(function (value) {
+      if (done) return
+      done = true
+      onFulfilled(value)
+    }, function (reason) {
+      if (done) return
+      done = true
+      onRejected(reason)
+    })
+  } catch (ex) {
+    if (done) return
+    done = true
+    onRejected(ex)
+  }
+}
 
 },{"asap":91}],90:[function(require,module,exports){
-'use strict';
-
-//This file contains the ES6 extensions to the core Promises/A+ API
-
-var Promise = require('./core.js')
-var asap = require('asap')
-
-module.exports = Promise
-
-/* Static Functions */
-
-function ValuePromise(value) {
-  this.then = function (onFulfilled) {
-    if (typeof onFulfilled !== 'function') return this
-    return new Promise(function (resolve, reject) {
-      asap(function () {
-        try {
-          resolve(onFulfilled(value))
-        } catch (ex) {
-          reject(ex);
-        }
-      })
-    })
-  }
-}
-ValuePromise.prototype = Promise.prototype
-
-var TRUE = new ValuePromise(true)
-var FALSE = new ValuePromise(false)
-var NULL = new ValuePromise(null)
-var UNDEFINED = new ValuePromise(undefined)
-var ZERO = new ValuePromise(0)
-var EMPTYSTRING = new ValuePromise('')
-
-Promise.resolve = function (value) {
-  if (value instanceof Promise) return value
-
-  if (value === null) return NULL
-  if (value === undefined) return UNDEFINED
-  if (value === true) return TRUE
-  if (value === false) return FALSE
-  if (value === 0) return ZERO
-  if (value === '') return EMPTYSTRING
-
-  if (typeof value === 'object' || typeof value === 'function') {
-    try {
-      var then = value.then
-      if (typeof then === 'function') {
-        return new Promise(then.bind(value))
-      }
-    } catch (ex) {
-      return new Promise(function (resolve, reject) {
-        reject(ex)
-      })
-    }
-  }
-
-  return new ValuePromise(value)
-}
-
-Promise.all = function (arr) {
-  var args = Array.prototype.slice.call(arr)
-
-  return new Promise(function (resolve, reject) {
-    if (args.length === 0) return resolve([])
-    var remaining = args.length
-    function res(i, val) {
-      try {
-        if (val && (typeof val === 'object' || typeof val === 'function')) {
-          var then = val.then
-          if (typeof then === 'function') {
-            then.call(val, function (val) { res(i, val) }, reject)
-            return
-          }
-        }
-        args[i] = val
-        if (--remaining === 0) {
-          resolve(args);
-        }
-      } catch (ex) {
-        reject(ex)
-      }
-    }
-    for (var i = 0; i < args.length; i++) {
-      res(i, args[i])
-    }
-  })
-}
-
-Promise.reject = function (value) {
-  return new Promise(function (resolve, reject) { 
-    reject(value);
-  });
-}
-
-Promise.race = function (values) {
-  return new Promise(function (resolve, reject) { 
-    values.forEach(function(value){
-      Promise.resolve(value).then(resolve, reject);
-    })
-  });
-}
-
-/* Prototype Methods */
-
-Promise.prototype['catch'] = function (onRejected) {
-  return this.then(null, onRejected);
-}
+'use strict';
+
+//This file contains the ES6 extensions to the core Promises/A+ API
+
+var Promise = require('./core.js')
+var asap = require('asap')
+
+module.exports = Promise
+
+/* Static Functions */
+
+function ValuePromise(value) {
+  this.then = function (onFulfilled) {
+    if (typeof onFulfilled !== 'function') return this
+    return new Promise(function (resolve, reject) {
+      asap(function () {
+        try {
+          resolve(onFulfilled(value))
+        } catch (ex) {
+          reject(ex);
+        }
+      })
+    })
+  }
+}
+ValuePromise.prototype = Promise.prototype
+
+var TRUE = new ValuePromise(true)
+var FALSE = new ValuePromise(false)
+var NULL = new ValuePromise(null)
+var UNDEFINED = new ValuePromise(undefined)
+var ZERO = new ValuePromise(0)
+var EMPTYSTRING = new ValuePromise('')
+
+Promise.resolve = function (value) {
+  if (value instanceof Promise) return value
+
+  if (value === null) return NULL
+  if (value === undefined) return UNDEFINED
+  if (value === true) return TRUE
+  if (value === false) return FALSE
+  if (value === 0) return ZERO
+  if (value === '') return EMPTYSTRING
+
+  if (typeof value === 'object' || typeof value === 'function') {
+    try {
+      var then = value.then
+      if (typeof then === 'function') {
+        return new Promise(then.bind(value))
+      }
+    } catch (ex) {
+      return new Promise(function (resolve, reject) {
+        reject(ex)
+      })
+    }
+  }
+
+  return new ValuePromise(value)
+}
+
+Promise.all = function (arr) {
+  var args = Array.prototype.slice.call(arr)
+
+  return new Promise(function (resolve, reject) {
+    if (args.length === 0) return resolve([])
+    var remaining = args.length
+    function res(i, val) {
+      try {
+        if (val && (typeof val === 'object' || typeof val === 'function')) {
+          var then = val.then
+          if (typeof then === 'function') {
+            then.call(val, function (val) { res(i, val) }, reject)
+            return
+          }
+        }
+        args[i] = val
+        if (--remaining === 0) {
+          resolve(args);
+        }
+      } catch (ex) {
+        reject(ex)
+      }
+    }
+    for (var i = 0; i < args.length; i++) {
+      res(i, args[i])
+    }
+  })
+}
+
+Promise.reject = function (value) {
+  return new Promise(function (resolve, reject) { 
+    reject(value);
+  });
+}
+
+Promise.race = function (values) {
+  return new Promise(function (resolve, reject) { 
+    values.forEach(function(value){
+      Promise.resolve(value).then(resolve, reject);
+    })
+  });
+}
+
+/* Prototype Methods */
+
+Promise.prototype['catch'] = function (onRejected) {
+  return this.then(null, onRejected);
+}
 
 },{"./core.js":89,"asap":91}],91:[function(require,module,exports){
 (function (process){
@@ -9726,29 +9821,29 @@ module.exports = asap;
 
 }).call(this,require('_process'))
 },{"_process":88}],92:[function(require,module,exports){
-// should work in any browser without browserify
-
-if (typeof Promise.prototype.done !== 'function') {
-  Promise.prototype.done = function (onFulfilled, onRejected) {
-    var self = arguments.length ? this.then.apply(this, arguments) : this
-    self.then(null, function (err) {
-      setTimeout(function () {
-        throw err
-      }, 0)
-    })
-  }
+// should work in any browser without browserify
+
+if (typeof Promise.prototype.done !== 'function') {
+  Promise.prototype.done = function (onFulfilled, onRejected) {
+    var self = arguments.length ? this.then.apply(this, arguments) : this
+    self.then(null, function (err) {
+      setTimeout(function () {
+        throw err
+      }, 0)
+    })
+  }
 }
 },{}],"promise/polyfill.js":[function(require,module,exports){
-// not "use strict" so we can declare global "Promise"
-
-var asap = require('asap');
-
-if (typeof Promise === 'undefined') {
-  Promise = require('./lib/core.js')
-  require('./lib/es6-extensions.js')
-}
-
-require('./polyfill-done.js');
+// not "use strict" so we can declare global "Promise"
+
+var asap = require('asap');
+
+if (typeof Promise === 'undefined') {
+  Promise = require('./lib/core.js')
+  require('./lib/es6-extensions.js')
+}
+
+require('./polyfill-done.js');
 
 },{"./lib/core.js":89,"./lib/es6-extensions.js":90,"./polyfill-done.js":92,"asap":91}]},{},[2])(2)
 });