less 2.3.3 → 2.4.0

data/lib/less/js/lib/less/import-visitor.js

@@ -0,0 +1,107 @@
+(function (tree) {
+    tree.importVisitor = function(importer, finish, evalEnv) {
+        this._visitor = new tree.visitor(this);
+        this._importer = importer;
+        this._finish = finish;
+        this.env = evalEnv || new tree.evalEnv();
+        this.importCount = 0;
+    };
+
+    tree.importVisitor.prototype = {
+        isReplacing: true,
+        run: function (root) {
+            var error;
+            try {
+                // process the contents
+                this._visitor.visit(root);
+            }
+            catch(e) {
+                error = e;
+            }
+
+            this.isFinished = true;
+
+            if (this.importCount === 0) {
+                this._finish(error);
+            }
+        },
+        visitImport: function (importNode, visitArgs) {
+            var importVisitor = this,
+                evaldImportNode;
+
+            if (!importNode.css) {
+
+                try {
+                    evaldImportNode = importNode.evalForImport(this.env);
+                } 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;
+                    // if that fails, this error will be thrown
+                    importNode.error = e;
+                }
+
+                if (evaldImportNode && !evaldImportNode.css) {
+                    importNode = evaldImportNode;
+                    this.importCount++;
+                    var env = new tree.evalEnv(this.env, this.env.frames.slice(0));
+                    this._importer.push(importNode.getPath(), importNode.currentFileInfo, function (e, root, imported) {
+                        if (e && !e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+                        if (imported && !importNode.options.multiple) { importNode.skip = imported; }
+
+                        var subFinish = function(e) {
+                            importVisitor.importCount--;
+
+                            if (importVisitor.importCount === 0 && importVisitor.isFinished) {
+                                importVisitor._finish(e);
+                            }
+                        };
+
+                        if (root) {
+                            importNode.root = root;
+                            new(tree.importVisitor)(importVisitor._importer, subFinish, env)
+                                .run(root);
+                        } else {
+                            subFinish();
+                        }
+                    });
+                }
+            }
+            visitArgs.visitDeeper = false;
+            return importNode;
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+            return ruleNode;
+        },
+        visitDirective: function (directiveNode, visitArgs) {
+            this.env.frames.unshift(directiveNode);
+            return directiveNode;
+        },
+        visitDirectiveOut: function (directiveNode) {
+            this.env.frames.shift();
+        },
+        visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+            this.env.frames.unshift(mixinDefinitionNode);
+            return mixinDefinitionNode;
+        },
+        visitMixinDefinitionOut: function (mixinDefinitionNode) {
+            this.env.frames.shift();
+        },
+        visitRuleset: function (rulesetNode, visitArgs) {
+            this.env.frames.unshift(rulesetNode);
+            return rulesetNode;
+        },
+        visitRulesetOut: function (rulesetNode) {
+            this.env.frames.shift();
+        },
+        visitMedia: function (mediaNode, visitArgs) {
+            this.env.frames.unshift(mediaNode.ruleset);
+            return mediaNode;
+        },
+        visitMediaOut: function (mediaNode) {
+            this.env.frames.shift();
+        }
+    };
+
+})(require('./tree'));

data/lib/less/js/lib/less/index.js

@@ -1,11 +1,11 @@
 var path = require('path'),
     sys = require('util'),
     url = require('url'),
-    http = require('http'),
+    request,
     fs = require('fs');
 
 var less = {
-    version: [1, 3, 3],
+    version: [1, 4, 2],
     Parser: require('./parser').Parser,
     importer: require('./parser').importer,
     tree: require('./tree'),
@@ -54,10 +54,14 @@ var less = {
             error.push(stylize((ctx.line - 1) + ' ' + extract[0], 'grey'));
         }
 
-        if (extract[1]) {
-            error.push(ctx.line + ' ' + extract[1].slice(0, ctx.column)
-                                + stylize(stylize(stylize(extract[1][ctx.column], 'bold')
-                                + extract[1].slice(ctx.column + 1), 'red'), 'inverse'));
+        if (typeof(extract[1]) === 'string') {
+            var errorTxt = ctx.line + ' ';
+            if (extract[1]) {
+                errorTxt += extract[1].slice(0, ctx.column) +
+                                stylize(stylize(stylize(extract[1][ctx.column], 'bold') +
+                                extract[1].slice(ctx.column + 1), 'red'), 'inverse');
+            }
+            error.push(errorTxt);
         }
 
         if (typeof(extract[2]) === 'string') {
@@ -67,7 +71,7 @@ var less = {
 
         message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
         ctx.filename && (message += stylize(' in ', 'red') + ctx.filename +
-                stylize(':' + ctx.line + ':' + ctx.column, 'grey'));
+                stylize(' on line ' + ctx.line + ', column ' + (ctx.column + 1) + ':', 'grey'));
 
         message += '\n' + error;
 
@@ -85,13 +89,13 @@ var less = {
     }
 };
 
-['color',      'directive',  'operation',  'dimension',
- 'keyword',    'variable',   'ruleset',    'element',
- 'selector',   'quoted',     'expression', 'rule',
- 'call',       'url',        'alpha',      'import',
- 'mixin',      'comment',    'anonymous',  'value',
- 'javascript', 'assignment', 'condition',  'paren',
- 'media',      'ratio',      'unicode-descriptor'
+['color',      'directive',  'operation',          'dimension',
+ 'keyword',    'variable',   'ruleset',            'element',
+ 'selector',   'quoted',     'expression',         'rule',
+ 'call',       'url',        'alpha',              'import',
+ 'mixin',      'comment',    'anonymous',          'value',
+ 'javascript', 'assignment', 'condition',          'paren',
+ 'media',      'unicode-descriptor', 'negative',   'extend'
 ].forEach(function (n) {
     require('./tree/' + n);
 });
@@ -99,14 +103,22 @@ var less = {
 
 var isUrlRe = /^(?:https?:)?\/\//i;
 
-less.Parser.importer = function (file, paths, callback, env) {
-    var pathname, dirname, data;
+less.Parser.importer = function (file, currentFileInfo, callback, env) {
+    var pathname, dirname, data,
+        newFileInfo = {
+            relativeUrls: env.relativeUrls,
+            entryPath: currentFileInfo.entryPath,
+            rootpath: currentFileInfo.rootpath,
+            rootFilename: currentFileInfo.rootFilename
+        };
 
     function parseFile(e, data) {
-        if (e) return callback(e);
+        if (e) { return callback(e); }
+
+        env = new less.tree.parseEnv(env);
+        env.processImports = false;
         
-        var rootpath = env.rootpath,
-            j = file.lastIndexOf('/');
+        var j = file.lastIndexOf('/');
 
         // Pass on an updated rootpath if path of imported file is relative and file 
         // is in a (sub|sup) directory
@@ -116,29 +128,32 @@ less.Parser.importer = function (file, paths, callback, env) {
         //   then rootpath should become 'less/module/nav/'
         // - If path of imported file is '../mixins.less' and rootpath is 'less/', 
         //   then rootpath should become 'less/../'
-        if(env.relativeUrls && !/^(?:[a-z-]+:|\/)/.test(file) && j != -1) {
-            rootpath = rootpath + file.slice(0, j+1); // append (sub|sup) directory path of imported file
+        if(newFileInfo.relativeUrls && !/^(?:[a-z-]+:|\/)/.test(file) && j != -1) {
+            var relativeSubDirectory = file.slice(0, j+1);
+            newFileInfo.rootpath = newFileInfo.rootpath + relativeSubDirectory; // append (sub|sup) directory path of imported file
         }
+        newFileInfo.currentDirectory = pathname.replace(/[^\\\/]*$/, "");
+        newFileInfo.filename = pathname;
 
         env.contents[pathname] = data;      // Updating top importing parser content cache.
-        new(less.Parser)({
-                paths: [dirname].concat(paths),
-                filename: pathname,
-                contents: env.contents,
-                files: env.files,
-                syncImport: env.syncImport,
-                relativeUrls: env.relativeUrls,
-                rootpath: rootpath,
-                dumpLineNumbers: env.dumpLineNumbers
-        }).parse(data, function (e, root) {
+        env.currentFileInfo = newFileInfo;
+        new(less.Parser)(env).parse(data, function (e, root) {
             callback(e, root, pathname);
         });
     };
     
     var isUrl = isUrlRe.test( file );
-    if (isUrl || isUrlRe.test(paths[0])) {
+    if (isUrl || isUrlRe.test(currentFileInfo.currentDirectory)) {
+        if (request === undefined) {
+            try { request = require('request'); }
+            catch(e) { request = null; }
+        }
+        if (!request) {
+            callback({ type: 'File', message: "optional dependency 'request' required to import over http(s)\n" });
+            return;
+        }
 
-        var urlStr = isUrl ? file : url.resolve(paths[0], file),
+        var urlStr = isUrl ? file : url.resolve(currentFileInfo.currentDirectory, file),
             urlObj = url.parse(urlStr),
             req = {
                 host:   urlObj.hostname,
@@ -146,31 +161,24 @@ less.Parser.importer = function (file, paths, callback, env) {
                 path:   urlObj.pathname + (urlObj.search||'')
             };
 
-        http.get(req, function (res) {
-            var body = '';
-            res.on('data', function (chunk) {
-                body += chunk.toString();
-            });
-            res.on('end', function () {
-                if (res.statusCode === 404) {
-                    callback({ type: 'File', message: "resource '" + urlStr + "' was not found\n" });
-                }
-                if (!body) {
-                    sys.error( 'Warning: Empty body (HTTP '+ res.statusCode + ') returned by "' + urlStr +'"' );
-                }
-                pathname = urlStr;
-                dirname = urlObj.protocol +'//'+ urlObj.host + urlObj.pathname.replace(/[^\/]*$/, '');
-                parseFile(null, body);
-            });
-        }).on('error', function (err) {
-            callback({ type: 'File', message: "resource '" + urlStr + "' gave this Error:\n  "+ err +"\n" });
+        request.get(urlStr, function (error, res, body) {
+            if (res.statusCode === 404) {
+                callback({ type: 'File', message: "resource '" + urlStr + "' was not found\n" });
+                return;
+            }
+            if (!body) {
+                sys.error( 'Warning: Empty body (HTTP '+ res.statusCode + ') returned by "' + urlStr +'"' );
+            }
+            if (error) {
+                callback({ type: 'File', message: "resource '" + urlStr + "' gave this Error:\n  "+ error +"\n" });
+            }
+            pathname = urlStr;
+            dirname = urlObj.protocol +'//'+ urlObj.host + urlObj.pathname.replace(/[^\/]*$/, '');
+            parseFile(null, body);
         });
-
     } else {
 
-        // TODO: Undo this at some point,
-        // or use different approach.
-        var paths = [].concat(paths);
+        var paths = [currentFileInfo.currentDirectory].concat(env.paths);
         paths.push('.');
 
         for (var i = 0; i < paths.length; i++) {
@@ -183,15 +191,9 @@ less.Parser.importer = function (file, paths, callback, env) {
             }
         }
         
-        paths = paths.slice(0, paths.length - 1);
-
         if (!pathname) {
 
-            if (typeof(env.errback) === "function") {
-                env.errback(file, paths, callback);
-            } else {
-                callback({ type: 'File', message: "'" + file + "' wasn't found.\n" });
-            }
+            callback({ type: 'File', message: "'" + file + "' wasn't found" });
             return;
         }
         
@@ -210,7 +212,12 @@ less.Parser.importer = function (file, paths, callback, env) {
     }
 }
 
+require('./env');
 require('./functions');
 require('./colors');
+require('./visitor.js');
+require('./import-visitor.js');
+require('./extend-visitor.js');
+require('./join-selector-visitor.js');
 
-for (var k in less) { exports[k] = less[k] }
+for (var k in less) { exports[k] = less[k]; }

data/lib/less/js/lib/less/join-selector-visitor.js

@@ -0,0 +1,37 @@
+(function (tree) {
+    tree.joinSelectorVisitor = function() {
+        this.contexts = [[]];
+        this._visitor = new tree.visitor(this);
+    };
+
+    tree.joinSelectorVisitor.prototype = {
+        run: function (root) {
+            return this._visitor.visit(root);
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+
+        visitRuleset: function (rulesetNode, visitArgs) {
+            var context = this.contexts[this.contexts.length - 1];
+            var paths = [];
+            this.contexts.push(paths);
+
+            if (! rulesetNode.root) {
+                rulesetNode.joinSelectors(paths, context, rulesetNode.selectors);
+                rulesetNode.paths = paths;
+            }
+        },
+        visitRulesetOut: function (rulesetNode) {
+            this.contexts.length = this.contexts.length - 1;
+        },
+        visitMedia: function (mediaNode, visitArgs) {
+            var context = this.contexts[this.contexts.length - 1];
+            mediaNode.ruleset.root = (context.length === 0 || context[0].multiMedia);
+        }
+    };
+
+})(require('./tree'));

data/lib/less/js/lib/less/lessc_helper.js

@@ -1,7 +1,7 @@
 // lessc_helper.js
 //
 //      helper functions for lessc
-sys = require('util');
+var sys = require('util');
 
 var lessc_helper = {
 
@@ -29,14 +29,18 @@ var lessc_helper = {
         sys.puts("");
         sys.puts("options:");
         sys.puts("  -h, --help              Print help (this message) and exit.");
-        sys.puts("  --include-path          Set include paths. Separated by `:'. Use `;' on Windows.");
+        sys.puts("  --include-path=PATHS    Set include paths. Separated by `:'. Use `;' on Windows.");
+        sys.puts("  -M, --depends           Output a makefile import dependency list to stdout");
         sys.puts("  --no-color              Disable colorized output.");
+        sys.puts("  --no-ie-compat          Disable IE compatibility checks.");
+        sys.puts("  -l, --lint              Syntax check only (lint).");
         sys.puts("  -s, --silent            Suppress output of error messages.");
         sys.puts("  --strict-imports        Force evaluation of imports.");
         sys.puts("  --verbose               Be verbose.");
         sys.puts("  -v, --version           Print version number and exit.");
         sys.puts("  -x, --compress          Compress output by removing some whitespaces.");
         sys.puts("  --yui-compress          Compress output using ycssmin");
+        sys.puts("  --max-line-len=LINELEN  Max line length used by ycssmin");
         sys.puts("  -O0, -O1, -O2           Set the parser's optimization level. The lower");
         sys.puts("                          the number, the less nodes it will create in the");
         sys.puts("                          tree. This could matter for debugging, or if you");
@@ -47,9 +51,14 @@ var lessc_helper = {
         sys.puts("                          that will output the information within a fake");
         sys.puts("                          media query which is compatible with the SASS");
         sys.puts("                          format, and 'all' which will do both.");
-        sys.puts("  -rp, --rootpath         Set rootpath for url rewriting in relative imports and urls.");
-        sys.puts("                          Works with or withour the relative-urls option.");
+        sys.puts("  -rp, --rootpath=URL     Set rootpath for url rewriting in relative imports and urls.");
+        sys.puts("                          Works with or without the relative-urls option.");
         sys.puts("  -ru, --relative-urls    re-write relative urls to the base less file.");
+        sys.puts("  -sm=on|off              Turn on or off strict math, where in strict mode, math");
+        sys.puts("  --strict-math=on|off    requires brackets. This option may default to on and then");
+        sys.puts("                          be removed in the future.");
+        sys.puts("  -su=on|off              Allow mixed units, e.g. 1px+1em or 1px*1px which have units");
+        sys.puts("  --strict-units=on|off   that cannot be represented.");
         sys.puts("");
         sys.puts("Report bugs to: http://github.com/cloudhead/less.js/issues");
         sys.puts("Home page: <http://lesscss.org/>");

data/lib/less/js/lib/less/parser.js

@@ -66,16 +66,10 @@ less.Parser = function Parser(env) {
     var that = this;
 
     // Top parser on an import tree must be sure there is one "env"
-    // which will then be passed arround by reference.
-    var env = env || { };
-    // env.contents and files must be passed arround with top env
-    if (!env.contents) { env.contents = {}; }
-    env.rootpath = env.rootpath || '';       // env.rootpath must be initialized to '' if not provided
-    if (!env.files) { env.files = {}; }
-
-    // This function is called after all files
-    // have been imported through `@import`.
-    var finish = function () {};
+    // which will then be passed around by reference.
+    if (!(env instanceof tree.parseEnv)) {
+        env = new tree.parseEnv(env);
+    }
 
     var imports = this.imports = {
         paths: env.paths || [],  // Search paths, when importing
@@ -84,31 +78,29 @@ less.Parser = function Parser(env) {
         contents: env.contents,  // Holds the imported file contents
         mime:  env.mime,         // MIME type of .less files
         error: null,             // Error in parsing/evaluating an import
-        push: function (path, callback) {
-            var that = this;
+        push: function (path, currentFileInfo, callback) {
+            var parserImporter = this;
             this.queue.push(path);
 
             //
             // Import a file asynchronously
             //
-            less.Parser.importer(path, this.paths, function (e, root, fullPath) {
-                that.queue.splice(that.queue.indexOf(path), 1); // Remove the path from the queue
-
-                var imported = fullPath in that.files;
+            less.Parser.importer(path, currentFileInfo, function (e, root, fullPath) {
+                parserImporter.queue.splice(parserImporter.queue.indexOf(path), 1); // Remove the path from the queue
 
-                that.files[fullPath] = root;                        // Store the root
+                var imported = fullPath in parserImporter.files;
 
-                if (e && !that.error) { that.error = e }
+                parserImporter.files[fullPath] = root;                        // Store the root
 
+                if (e && !parserImporter.error) { parserImporter.error = e; }
+                
                 callback(e, root, imported);
-
-                if (that.queue.length === 0) { finish(that.error) }       // Call `finish` if we're done importing
             }, env);
         }
     };
 
-    function save()    { temp = chunks[j], memo = i, current = i }
-    function restore() { chunks[j] = temp, i = memo, current = i }
+    function save()    { temp = chunks[j], memo = i, current = i; }
+    function restore() { chunks[j] = temp, i = memo, current = i; }
 
     function sync() {
         if (i > current) {
@@ -217,7 +209,7 @@ less.Parser = function Parser(env) {
     }
 
     function getInput(e, env) {
-        if (e.filename && env.filename && (e.filename !== env.filename)) {
+        if (e.filename && env.currentFileInfo.filename && (e.filename !== env.currentFileInfo.filename)) {
             return parser.imports.contents[e.filename];
         } else {
             return input;
@@ -233,17 +225,15 @@ less.Parser = function Parser(env) {
                  column: column };
     }
 
-    function getFileName(e) {
-        if(less.mode === 'browser' || less.mode === 'rhino')
-            return e.filename;
-        else
-            return require('path').resolve(e.filename);
-    }
+    function getDebugInfo(index, inputStream, env) {
+        var filename = env.currentFileInfo.filename;
+        if(less.mode !== 'browser' && less.mode !== 'rhino') {
+            filename = require('path').resolve(filename);
+        }
 
-    function getDebugInfo(index, inputStream, e) {
         return {
             lineNumber: getLocation(index, inputStream).line + 1,
-            fileName: getFileName(e)
+            fileName: filename
         };
     }
 
@@ -256,7 +246,7 @@ less.Parser = function Parser(env) {
 
         this.type = e.type || 'Syntax';
         this.message = e.message;
-        this.filename = e.filename || env.filename;
+        this.filename = e.filename || env.currentFileInfo.filename;
         this.index = e.index;
         this.line = typeof(line) === 'number' ? line + 1 : null;
         this.callLine = e.call && (getLocation(e.call, input).line + 1);
@@ -270,6 +260,9 @@ less.Parser = function Parser(env) {
         ];
     }
 
+    LessError.prototype = new Error();
+    LessError.prototype.constructor = LessError;
+
     this.env = env = env || {};
 
     // The optimization level dictates the thoroughness of the parser,
@@ -278,8 +271,6 @@ less.Parser = function Parser(env) {
     // the individual nodes in the tree.
     this.optimization = ('optimization' in this.env) ? this.env.optimization : 1;
 
-    this.env.filename = this.env.filename || null;
-
     //
     // The Parser
     //
@@ -357,7 +348,7 @@ less.Parser = function Parser(env) {
                         index: i-1,
                         type: 'Parse',
                         message: (level > 0) ? "missing closing `}`" : "missing opening `{`",
-                        filename: env.filename
+                        filename: env.currentFileInfo.filename
                     }, env);
                 }
 
@@ -365,7 +356,7 @@ less.Parser = function Parser(env) {
             })([[]]);
 
             if (error) {
-                return callback(error, env);
+                return callback(new(LessError)(error, env));
             }
 
             // Start with the primary rule.
@@ -375,6 +366,7 @@ less.Parser = function Parser(env) {
             try {
                 root = new(tree.Ruleset)([], $(this.parsers.primary));
                 root.root = true;
+                root.firstRoot = true;
             } catch (e) {
                 return callback(new(LessError)(e, env));
             }
@@ -383,9 +375,10 @@ less.Parser = function Parser(env) {
                 var line, lines, column;
 
                 return function (options, variables) {
-                    var frames = [], importError;
-
                     options = options || {};
+                    var importError,
+                        evalEnv = new tree.evalEnv(options);
+                        
                     //
                     // Allows setting variables with a hash, so:
                     //
@@ -411,23 +404,28 @@ less.Parser = function Parser(env) {
                             }
                             return new(tree.Rule)('@' + k, value, false, 0);
                         });
-                        frames = [new(tree.Ruleset)(null, variables)];
+                        evalEnv.frames = [new(tree.Ruleset)(null, variables)];
                     }
 
                     try {
-                        var css = evaluate.call(this, { frames: frames })
-                                          .toCSS([], { compress: options.compress || false, dumpLineNumbers: env.dumpLineNumbers });
+                        var evaldRoot = evaluate.call(this, evalEnv);
+
+                        new(tree.joinSelectorVisitor)()
+                            .run(evaldRoot);
+
+                        new(tree.processExtendsVisitor)()
+                            .run(evaldRoot);
+
+                        var css = evaldRoot.toCSS({
+                                compress: Boolean(options.compress),
+                                dumpLineNumbers: env.dumpLineNumbers,
+                                strictUnits: Boolean(options.strictUnits)});
                     } catch (e) {
                         throw new(LessError)(e, env);
                     }
 
-                    if ((importError = parser.imports.error)) { // Check if there was an error during importing
-                        if (importError instanceof LessError) throw importError;
-                        else                                  throw new(LessError)(importError, env);
-                    }
-
                     if (options.yuicompress && less.mode === 'node') {
-                        return require('ycssmin').cssmin(css);
+                        return require('ycssmin').cssmin(css, options.maxLineLen);
                     } else if (options.compress) {
                         return css.replace(/(\s)+/g, "$1");
                     } else {
@@ -453,9 +451,9 @@ less.Parser = function Parser(env) {
 
                 error = {
                     type: "Parse",
-                    message: "Syntax Error on line " + line,
+                    message: "Unrecognised input",
                     index: i,
-                    filename: env.filename,
+                    filename: env.currentFileInfo.filename,
                     line: line,
                     column: column,
                     extract: [
@@ -466,14 +464,26 @@ less.Parser = function Parser(env) {
                 };
             }
 
-            if (this.imports.queue.length > 0) {
-                finish = function (e) {
-                    e = error || e;
-                    if (e) callback(e);
-                    else callback(null, root);
-                };
+            var finish = function (e) {
+                e = error || e || parser.imports.error;
+
+                if (e) {
+                    if (!(e instanceof LessError)) {
+                        e = new(LessError)(e, env);
+                    }
+
+                    callback(e);
+                }
+                else {
+                    callback(null, root);
+                }
+            };
+
+            if (env.processImports !== false) {
+                new tree.importVisitor(this.imports, finish)
+                    .run(root);
             } else {
-                callback(error, root);
+                finish();
             }
         },
 
@@ -525,7 +535,7 @@ less.Parser = function Parser(env) {
             primary: function () {
                 var node, root = [];
 
-                while ((node = $(this.mixin.definition) || $(this.rule)    ||  $(this.ruleset) ||
+                while ((node = $(this.extendRule) || $(this.mixin.definition) || $(this.rule)    ||  $(this.ruleset) ||
                                $(this.mixin.call)       || $(this.comment) ||  $(this.directive))
                                || $(/^[\s\n]+/) || $(/^;+/)) {
                     node && root.push(node);
@@ -558,7 +568,7 @@ less.Parser = function Parser(env) {
                 //     "milky way" 'he\'s the one!'
                 //
                 quoted: function () {
-                    var str, j = i, e;
+                    var str, j = i, e, index = i;
 
                     if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
                     if (input.charAt(j) !== '"' && input.charAt(j) !== "'") return;
@@ -566,7 +576,7 @@ less.Parser = function Parser(env) {
                     e && $('~');
 
                     if (str = $(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/)) {
-                        return new(tree.Quoted)(str[0], str[1] || str[2], e);
+                        return new(tree.Quoted)(str[0], str[1] || str[2], e, index, env.currentFileInfo);
                     }
                 },
 
@@ -607,7 +617,7 @@ less.Parser = function Parser(env) {
                     nameLC = name.toLowerCase();
 
                     if (nameLC === 'url') { return null }
-                    else                { i += name.length }
+                    else                  { i += name.length }
 
                     if (nameLC === 'alpha') {
                         alpha_ret = $(this.alpha);
@@ -620,9 +630,11 @@ less.Parser = function Parser(env) {
 
                     args = $(this.entities.arguments);
 
-                    if (! $(')')) return;
+                    if (! $(')')) {
+                        return;
+                    }
 
-                    if (name) { return new(tree.Call)(name, args, index, env.filename) }
+                    if (name) { return new(tree.Call)(name, args, index, env.currentFileInfo); }
                 },
                 arguments: function () {
                     var args = [], arg;
@@ -634,8 +646,7 @@ less.Parser = function Parser(env) {
                     return args;
                 },
                 literal: function () {
-                    return $(this.entities.ratio) ||
-                           $(this.entities.dimension) ||
+                    return $(this.entities.dimension) ||
                            $(this.entities.color) ||
                            $(this.entities.quoted) ||
                            $(this.entities.unicodeDescriptor);
@@ -671,7 +682,7 @@ less.Parser = function Parser(env) {
                     expect(')');
 
                     return new(tree.URL)((value.value != null || value instanceof tree.Variable)
-                                        ? value : new(tree.Anonymous)(value), env.rootpath);
+                                        ? value : new(tree.Anonymous)(value), env.currentFileInfo);
                 },
 
                 //
@@ -686,7 +697,7 @@ less.Parser = function Parser(env) {
                     var name, index = i;
 
                     if (input.charAt(i) === '@' && (name = $(/^@@?[\w-]+/))) {
-                        return new(tree.Variable)(name, index, env.filename);
+                        return new(tree.Variable)(name, index, env.currentFileInfo);
                     }
                 },
 
@@ -695,7 +706,7 @@ less.Parser = function Parser(env) {
                     var name, curly, index = i;
 
                     if (input.charAt(i) === '@' && (curly = $(/^@\{([\w-]+)\}/))) {
-                        return new(tree.Variable)("@" + curly[1], index, env.filename);
+                        return new(tree.Variable)("@" + curly[1], index, env.currentFileInfo);
                     }
                 },
 
@@ -724,25 +735,11 @@ less.Parser = function Parser(env) {
                     //Is the first char of the dimension 0-9, '.', '+' or '-'
                     if ((c > 57 || c < 43) || c === 47 || c == 44) return;
 
-                    if (value = $(/^([+-]?\d*\.?\d+)(px|%|em|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn|dpi|dpcm|dppx|rem|vw|vh|vmin|vm|ch)?/)) {
+                    if (value = $(/^([+-]?\d*\.?\d+)(%|[a-z]+)?/)) {
                         return new(tree.Dimension)(value[1], value[2]);
                     }
                 },
 
-                //
-                // A Ratio
-                //
-                //    16/9
-                //
-                ratio: function () {
-                  var value, c = input.charCodeAt(i);
-                  if (c > 57 || c < 48) return;
-
-                  if (value = $(/^(\d+\/\d+)/)) {
-                    return new(tree.Ratio)(value[1]);
-                  }
-                },
-                
                 //
                 // A unicode descriptor, as is used in unicode-range
                 //
@@ -787,26 +784,46 @@ less.Parser = function Parser(env) {
             },
 
             //
-            // A font size/line-height shorthand
-            //
-            //     small/12px
-            //
-            // We need to peek first, or we'll match on keywords and dimensions
+            // extend syntax - used to extend selectors
             //
-            shorthand: function () {
-                var a, b;
+            extend: function(isRule) {
+                var elements, e, index = i, option, extendList = [];
 
-                if (! peek(/^[@\w.%-]+\/[@\w.-]+/)) return;
+                if (!$(isRule ? /^&:extend\(/ : /^:extend\(/)) { return; }
 
-                save();
+                do {
+                    option = null;
+                    elements = [];
+                    while (true) {
+                        option = $(/^(all)(?=\s*(\)|,))/);
+                        if (option) { break; }
+                        e = $(this.element);
+                        if (!e) { break; }
+                        elements.push(e);
+                    }
+
+                    option = option && option[1];
+
+                    extendList.push(new(tree.Extend)(new(tree.Selector)(elements), option, index));
+
+                } while($(","))
+                
+                expect(/^\)/);
 
-                if ((a = $(this.entity)) && $('/') && (b = $(this.entity))) {
-                    return new(tree.Shorthand)(a, b);
+                if (isRule) {
+                    expect(/^;/);
                 }
 
-                restore();
+                return extendList;
             },
 
+            //
+            // extendRule - used in a rule to extend all the parent selectors
+            //
+            extendRule: function() {
+                return this.extend(true);
+            },
+            
             //
             // Mixins
             //
@@ -823,10 +840,10 @@ less.Parser = function Parser(env) {
                 // selector for now.
                 //
                 call: function () {
-                    var elements = [], e, c, argsSemiColon = [], argsComma = [], args, delim, arg, nameLoop, expressions, isSemiColonSeperated, expressionContainsNamed, index = i, s = input.charAt(i), name, value, important = false;
+                    var elements = [], e, c, args, delim, arg, index = i, s = input.charAt(i), important = false;
 
                     if (s !== '.' && s !== '#') { return }
-                    
+
                     save(); // stop us absorbing part of an invalid selector
 
                     while (e = $(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/)) {
@@ -834,71 +851,119 @@ less.Parser = function Parser(env) {
                         c = $('>');
                     }
                     if ($('(')) {
-                        expressions = [];
-                        while (arg = $(this.expression)) {
-                            nameLoop = null;
-                            value = arg;
+                        args = this.mixin.args.call(this, true).args;
+                        expect(')');
+                    }
+
+                    args = args || [];
 
+                    if ($(this.important)) {
+                        important = true;
+                    }
+
+                    if (elements.length > 0 && ($(';') || peek('}'))) {
+                        return new(tree.mixin.Call)(elements, args, index, env.currentFileInfo, important);
+                    }
+
+                    restore();
+                },
+                args: function (isCall) {
+                    var expressions = [], argsSemiColon = [], isSemiColonSeperated, argsComma = [], expressionContainsNamed, name, nameLoop, value, arg,
+                        returner = {args:null, variadic: false};
+                    while (true) {
+                        if (isCall) {
+                            arg = $(this.expression);
+                        } else {
+                            $(this.comment);
+                            if (input.charAt(i) === '.' && $(/^\.{3}/)) {
+                                returner.variadic = true;
+                                if ($(";") && !isSemiColonSeperated) {
+                                    isSemiColonSeperated = true;
+                                }
+                                (isSemiColonSeperated ? argsSemiColon : argsComma)
+                                    .push({ variadic: true });
+                                break;
+                            }
+                            arg = $(this.entities.variable) || $(this.entities.literal)
+                                || $(this.entities.keyword);
+                        }
+
+                        if (!arg) {
+                            break;
+                        }
+
+                        nameLoop = null;
+                        if (arg.throwAwayComments) {
+                            arg.throwAwayComments();
+                        }
+                        value = arg;
+                        var val = null;
+
+                        if (isCall) {
                             // Variable
                             if (arg.value.length == 1) {
                                 var val = arg.value[0];
-                                if (val instanceof tree.Variable) {
-                                    if ($(':')) {
-                                        if (expressions.length > 0) {
-                                            if (isSemiColonSeperated) {
-                                                error("Cannot mix ; and , as delimiter types");
-                                            }
-                                            expressionContainsNamed = true;
-                                        }
-                                        value = expect(this.expression);
-                                        nameLoop = (name = val.name);
-                                    }
-                                }
-                            }
-                            
-                            expressions.push(value);
-                            
-                            argsComma.push({ name: nameLoop, value: value });
-                            
-                            if ($(',')) {
-                                continue;
                             }
-                            
-                            if ($(';') || isSemiColonSeperated) {
-                            
-                                if (expressionContainsNamed) {
-                                    error("Cannot mix ; and , as delimiter types");
+                        } else {
+                            val = arg;
+                        }
+
+                        if (val && val instanceof tree.Variable) {
+                            if ($(':')) {
+                                if (expressions.length > 0) {
+                                    if (isSemiColonSeperated) {
+                                        error("Cannot mix ; and , as delimiter types");
+                                    }
+                                    expressionContainsNamed = true;
                                 }
-                            
-                                isSemiColonSeperated = true;
-                                                        
-                                if (expressions.length > 1) {
-                                    value = new(tree.Value)(expressions);
+                                value = expect(this.expression);
+                                nameLoop = (name = val.name);
+                            } else if (!isCall && $(/^\.{3}/)) {
+                                returner.variadic = true;
+                                if ($(";") && !isSemiColonSeperated) {
+                                    isSemiColonSeperated = true;
                                 }
-                                argsSemiColon.push({ name: name, value: value });
-                            
-                                name = null;
-                                expressions = [];
-                                expressionContainsNamed = false;
+                                (isSemiColonSeperated ? argsSemiColon : argsComma)
+                                    .push({ name: arg.name, variadic: true });
+                                break;
+                            } else if (!isCall) {
+                                name = nameLoop = val.name;
+                                value = null;
                             }
                         }
 
-                        expect(')');
-                    }
+                        if (value) {
+                            expressions.push(value);
+                        }
 
-                    args = isSemiColonSeperated ? argsSemiColon : argsComma;
+                        argsComma.push({ name:nameLoop, value:value });
 
-                    if ($(this.important)) {
-                        important = true;
-                    }
+                        if ($(',')) {
+                            continue;
+                        }
 
-                    if (elements.length > 0 && ($(';') || peek('}'))) {
-                        return new(tree.mixin.Call)(elements, args, index, env.filename, important);
+                        if ($(';') || isSemiColonSeperated) {
+
+                            if (expressionContainsNamed) {
+                                error("Cannot mix ; and , as delimiter types");
+                            }
+
+                            isSemiColonSeperated = true;
+
+                            if (expressions.length > 1) {
+                                value = new (tree.Value)(expressions);
+                            }
+                            argsSemiColon.push({ name:name, value:value });
+
+                            name = null;
+                            expressions = [];
+                            expressionContainsNamed = false;
+                        }
                     }
-                    
-                    restore();
-                },
 
+                    returner.args = isSemiColonSeperated ? argsSemiColon : argsComma;
+                    return returner;
+                },
                 //
                 // A Mixin definition, with a list of parameters
                 //
@@ -928,35 +993,11 @@ less.Parser = function Parser(env) {
                     if (match = $(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/)) {
                         name = match[1];
 
-                        do {
-                            $(this.comment);
-                            if (input.charAt(i) === '.' && $(/^\.{3}/)) {
-                                variadic = true;
-                                params.push({ variadic: true });
-                                break;
-                            } else if (param = $(this.entities.variable) || $(this.entities.literal)
-                                                                         || $(this.entities.keyword)) {
-                                // Variable
-                                if (param instanceof tree.Variable) {
-                                    if ($(':')) {
-                                        value = expect(this.expression, 'expected expression');
-                                        params.push({ name: param.name, value: value });
-                                    } else if ($(/^\.{3}/)) {
-                                        params.push({ name: param.name, variadic: true });
-                                        variadic = true;
-                                        break;
-                                    } else {
-                                        params.push({ name: param.name });
-                                    }
-                                } else {
-                                    params.push({ value: param });
-                                }
-                            } else {
-                                break;
-                            }
-                        } while ($(',') || $(';'))
+                        var argInfo = this.mixin.args.call(this, false);
+                        params = argInfo.args;
+                        variadic = argInfo.variadic;
 
-                        // .mixincall("@{a}"); 
+                        // .mixincall("@{a}");
                         // looks a bit like a mixin definition.. so we have to be nice and restore
                         if (!$(')')) {
                             furthest = i;
@@ -1036,9 +1077,7 @@ less.Parser = function Parser(env) {
 
                 if (! e) {
                     if ($('(')) {
-                        if ((v = ($(this.entities.variableCurly) || 
-                                $(this.entities.variable) || 
-                                $(this.selector))) && 
+                        if ((v = ($(this.selector))) &&
                                 $(')')) {
                             e = new(tree.Paren)(v);
                         }
@@ -1058,7 +1097,7 @@ less.Parser = function Parser(env) {
             // we deal with this in *combinator.js*.
             //
             combinator: function () {
-                var match, c = input.charAt(i);
+                var c = input.charAt(i);
 
                 if (c === '>' || c === '+' || c === '~' || c === '|') {
                     i++;
@@ -1080,38 +1119,41 @@ less.Parser = function Parser(env) {
             // Selectors are made out of one or more Elements, see above.
             //
             selector: function () {
-                var sel, e, elements = [], c, match;
+                var sel, e, elements = [], c, extend, extendList = [];
 
-                // depreciated, will be removed soon
-                if ($('(')) {
-                    sel = $(this.entity);
-                    if (!$(')')) { return null; }
-                    return new(tree.Selector)([new(tree.Element)('', sel, i)]);
-                }
-
-                while (e = $(this.element)) {
-                    c = input.charAt(i);
-                    elements.push(e)
+                while ((extend = $(this.extend)) || (e = $(this.element))) {
+                    if (extend) {
+                        extendList.push.apply(extendList, extend);
+                    } else {
+                        if (extendList.length) {
+                            error("Extend can only be used at the end of selector");
+                        }
+                        c = input.charAt(i);
+                        elements.push(e)
+                        e = null;
+                    }
                     if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') { break }
                 }
 
-                if (elements.length > 0) { return new(tree.Selector)(elements) }
+                if (elements.length > 0) { return new(tree.Selector)(elements, extendList); }
+                if (extendList.length) { error("Extend must be used to extend a selector, it cannot be used on its own"); }
             },
             attribute: function () {
                 var attr = '', key, val, op;
 
                 if (! $('[')) return;
 
-                if (key = $(/^(?:[_A-Za-z0-9-]|\\.)+/) || $(this.entities.quoted)) {
-                    if ((op = $(/^[|~*$^]?=/)) &&
-                        (val = $(this.entities.quoted) || $(/^[\w-]+/))) {
-                        attr = [key, op, val.toCSS ? val.toCSS() : val].join('');
-                    } else { attr = key }
+                if (!(key = $(this.entities.variableCurly))) {
+                    key = expect(/^(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/);
+                }
+
+                if ((op = $(/^[|~*$^]?=/))) {
+                    val = $(this.entities.quoted) || $(/^[\w-]+/) || $(this.entities.variableCurly);
                 }
 
-                if (! $(']')) return;
+                expect(']');
 
-                if (attr) { return "[" + attr + "]" }
+                return new(tree.Attribute)(key, op, val);
             },
 
             //
@@ -1129,7 +1171,7 @@ less.Parser = function Parser(env) {
             // div, .class, body > p {...}
             //
             ruleset: function () {
-                var selectors = [], s, rules, match, debugInfo;
+                var selectors = [], s, rules, debugInfo;
                 
                 save();
 
@@ -1154,31 +1196,39 @@ less.Parser = function Parser(env) {
                     restore();
                 }
             },
-            rule: function () {
-                var name, value, c = input.charAt(i), important, match;
+            rule: function (tryAnonymous) {
+                var name, value, c = input.charAt(i), important;
                 save();
 
                 if (c === '.' || c === '#' || c === '&') { return }
 
                 if (name = $(this.variable) || $(this.property)) {
-                    if ((name.charAt(0) != '@') && (match = /^([^@+\/'"*`(;{}-]*);/.exec(chunks[j]))) {
-                        i += match[0].length - 1;
-                        value = new(tree.Anonymous)(match[1]);
-                    } else if (name === "font") {
-                        value = $(this.font);
-                    } else {
-                        value = $(this.value);
-                    }
+                    // prefer to try to parse first if its a variable or we are compressing
+                    // but always fallback on the other one
+                    value = !tryAnonymous && (env.compress || (name.charAt(0) === '@')) ?
+                        ($(this.value) || $(this.anonymousValue)) :
+                        ($(this.anonymousValue) || $(this.value));
+
                     important = $(this.important);
 
                     if (value && $(this.end)) {
-                        return new(tree.Rule)(name, value, important, memo);
+                        return new(tree.Rule)(name, value, important, memo, env.currentFileInfo);
                     } else {
                         furthest = i;
                         restore();
+                        if (value && !tryAnonymous) {
+                            return this.rule(true);
+                        }
                     }
                 }
             },
+            anonymousValue: function () {
+                var match;
+                if (match = /^([^@+\/'"*`(;{}-]*);/.exec(chunks[j])) {
+                    i += match[0].length - 1;
+                    return new(tree.Anonymous)(match[1]);
+                }
+            },
 
             //
             // An @import directive
@@ -1192,21 +1242,58 @@ less.Parser = function Parser(env) {
             //
             "import": function () {
                 var path, features, index = i;
-                
+
                 save();
-                
-                var dir = $(/^@import(?:-(once))?\s+/);
+
+                var dir = $(/^@import?\s+/);
+
+                var options = (dir ? $(this.importOptions) : null) || {};
 
                 if (dir && (path = $(this.entities.quoted) || $(this.entities.url))) {
                     features = $(this.mediaFeatures);
                     if ($(';')) {
-                        return new(tree.Import)(path, imports, features, (dir[1] === 'once'), index, env.rootpath);
+                        features = features && new(tree.Value)(features);
+                        return new(tree.Import)(path, features, options, index, env.currentFileInfo);
                     }
                 }
-                
+
                 restore();
             },
 
+            importOptions: function() {
+                var o, options = {}, optionName, value;
+
+                // list of options, surrounded by parens
+                if (! $('(')) { return null; }
+                do {
+                    if (o = $(this.importOption)) {
+                        optionName = o;
+                        value = true;
+                        switch(optionName) {
+                            case "css":
+                                optionName = "less";
+                                value = false;
+                            break;
+                            case "once":
+                                optionName = "multiple";
+                                value = false;
+                            break;
+                        }
+                        options[optionName] = value;
+                        if (! $(',')) { break }
+                    }
+                } while (o);
+                expect(')');
+                return options;
+            },
+
+            importOption: function() {
+                var opt = $(/^(less|css|multiple|once)/);
+                if (opt) {
+                    return opt[1];
+                }
+            },
+
             mediaFeature: function () {
                 var e, p, nodes = [];
 
@@ -1215,10 +1302,10 @@ less.Parser = function Parser(env) {
                         nodes.push(e);
                     } else if ($('(')) {
                         p = $(this.property);
-                        e = $(this.entity);
+                        e = $(this.value);
                         if ($(')')) {
                             if (p && e) {
-                                nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, i, true)));
+                                nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, i, env.currentFileInfo, true)));
                             } else if (e) {
                                 nodes.push(new(tree.Paren)(e));
                             } else {
@@ -1281,7 +1368,7 @@ less.Parser = function Parser(env) {
                 if (value = $(this['import']) || $(this.media)) {
                     return value;
                 }
-                
+
                 save();
 
                 name = $(/^@[a-z-]+/);
@@ -1346,24 +1433,8 @@ less.Parser = function Parser(env) {
                         return directive;
                     }
                 }
-                
-                restore();
-            },
-            font: function () {
-                var value = [], expression = [], weight, shorthand, font, e;
 
-                while (e = $(this.shorthand) || $(this.entity)) {
-                    expression.push(e);
-                }
-                value.push(new(tree.Expression)(expression));
-
-                if ($(',')) {
-                    while (e = $(this.expression)) {
-                        value.push(e);
-                        if (! $(',')) { break }
-                    }
-                }
-                return new(tree.Value)(value);
+                restore();
             },
 
             //
@@ -1392,27 +1463,44 @@ less.Parser = function Parser(env) {
                 }
             },
             sub: function () {
-                var e;
+                var a, e;
 
-                if ($('(') && (e = $(this.expression)) && $(')')) {
-                    return e;
+                if ($('(')) {
+                    if (a = $(this.addition)) {
+                        e = new(tree.Expression)([a]);
+                        expect(')');
+                        e.parens = true;
+                        return e;
+                    }
                 }
             },
             multiplication: function () {
-                var m, a, op, operation;
+                var m, a, op, operation, isSpaced, expression = [];
                 if (m = $(this.operand)) {
-                    while (!peek(/^\/[*\/]/) && (op = ($('/') || $('*'))) && (a = $(this.operand))) {
-                        operation = new(tree.Operation)(op, [operation || m, a]);
+                    isSpaced = isWhitespace(input.charAt(i - 1));
+                    while (!peek(/^\/[*\/]/) && (op = ($('/') || $('*')))) {
+                        if (a = $(this.operand)) {
+                            m.parensInOp = true;
+                            a.parensInOp = true;
+                            operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
+                            isSpaced = isWhitespace(input.charAt(i - 1));
+                        } else {
+                            break;
+                        }
                     }
                     return operation || m;
                 }
             },
             addition: function () {
-                var m, a, op, operation;
+                var m, a, op, operation, isSpaced;
                 if (m = $(this.multiplication)) {
-                    while ((op = $(/^[-+]\s+/) || (!isWhitespace(input.charAt(i - 1)) && ($('+') || $('-')))) &&
+                    isSpaced = isWhitespace(input.charAt(i - 1));
+                    while ((op = $(/^[-+]\s+/) || (!isSpaced && ($('+') || $('-')))) &&
                            (a = $(this.multiplication))) {
-                        operation = new(tree.Operation)(op, [operation || m, a]);
+                        m.parensInOp = true;
+                        a.parensInOp = true;
+                        operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
+                        isSpaced = isWhitespace(input.charAt(i - 1));
                     }
                     return operation || m;
                 }
@@ -1458,8 +1546,13 @@ less.Parser = function Parser(env) {
                 var o = $(this.sub) || $(this.entities.dimension) ||
                         $(this.entities.color) || $(this.entities.variable) ||
                         $(this.entities.call);
-                return negate ? new(tree.Operation)('*', [new(tree.Dimension)(-1), o])
-                              : o;
+
+                if (negate) {
+                    o.parensInOp = true;
+                    o = new(tree.Negative)(o);
+                }
+
+                return o;
             },
 
             //
@@ -1474,6 +1567,10 @@ less.Parser = function Parser(env) {
 
                 while (e = $(this.addition) || $(this.entity)) {
                     entities.push(e);
+                    // operations do not allow keyword "/" dimension (e.g. small/20px) so we support that here
+                    if (!peek(/^\/[\/*]/) && (delim = $('/'))) {
+                        entities.push(new(tree.Anonymous)(delim));
+                    }
                 }
                 if (entities.length > 0) {
                     return new(tree.Expression)(entities);
@@ -1482,7 +1579,7 @@ less.Parser = function Parser(env) {
             property: function () {
                 var name;
 
-                if (name = $(/^(\*?-?[_a-z0-9-]+)\s*:/)) {
+                if (name = $(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/)) {
                     return name[1];
                 }
             }
@@ -1494,29 +1591,21 @@ if (less.mode === 'browser' || less.mode === 'rhino') {
     //
     // Used by `@import` directives
     //
-    less.Parser.importer = function (path, paths, callback, env) {
-        if (!/^([a-z-]+:)?\//.test(path) && paths.length > 0) {
-            path = paths[0] + path;
+    less.Parser.importer = function (path, currentFileInfo, callback, env) {
+        if (!/^([a-z-]+:)?\//.test(path) && currentFileInfo.currentDirectory) {
+            path = currentFileInfo.currentDirectory + path;
         }
+        var sheetEnv = env.toSheet(path);
+        sheetEnv.processImports = false;
+        sheetEnv.currentFileInfo = currentFileInfo;
+
         // We pass `true` as 3rd argument, to force the reload of the import.
         // This is so we can get the syntax tree as opposed to just the CSS output,
         // as we need this to evaluate the current stylesheet.
-        loadStyleSheet({ 
-            href: path, 
-            title: path, 
-            type: env.mime, 
-            contents: env.contents, 
-            files: env.files, 
-            rootpath: env.rootpath,
-            entryPath: env.entryPath,
-            relativeUrls: env.relativeUrls }, 
-        function (e, root, data, sheet, _, path) {
-            if (e && typeof(env.errback) === "function") {
-                env.errback.call(null, path, paths, callback, env);
-            } else {
+        loadStyleSheet(sheetEnv,
+            function (e, root, data, sheet, _, path) {
                 callback.call(null, e, root, path);
-            }
-        }, true);
+            }, true);
     };
 }