less 2.4.0 → 2.5.0

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

@@ -1,23 +1,10 @@
-var less, tree, charset;
-
-if (typeof environment === "object" && ({}).toString.call(environment) === "[object Environment]") {
-    // Rhino
-    // Details on how to detect Rhino: https://github.com/ringo/ringojs/issues/88
-    if (typeof(window) === 'undefined') { less = {} }
-    else                                { less = window.less = {} }
-    tree = less.tree = {};
-    less.mode = 'rhino';
-} else if (typeof(window) === 'undefined') {
-    // Node.js
-    less = exports,
+var less, tree;
+
+// Node.js does not have a header file added which defines less
+if (less === undefined) {
+    less = exports;
     tree = require('./tree');
     less.mode = 'node';
-} else {
-    // Browser
-    if (typeof(window.less) === 'undefined') { window.less = {} }
-    less = window.less,
-    tree = window.less.tree = {};
-    less.mode = 'browser';
 }
 //
 // less.js - parser
@@ -32,7 +19,7 @@ if (typeof environment === "object" && ({}).toString.call(environment) === "[obj
 //    - Matching and slicing on a huge input is often cause of slowdowns.
 //      The solution is to chunkify the input into smaller strings.
 //      The chunks are stored in the `chunks` var,
-//      `j` holds the current chunk index, and `current` holds
+//      `j` holds the current chunk index, and `currentPos` holds
 //      the index of the current chunk in relation to `input`.
 //      This gives us an almost 4x speed-up.
 //
@@ -60,10 +47,11 @@ less.Parser = function Parser(env) {
         memo,        // temporarily holds `i`, when backtracking
         furthest,    // furthest index the parser has gone to
         chunks,      // chunkified input
-        current,     // index of current chunk, in `input`
-        parser;
-
-    var that = this;
+        current,     // current chunk
+        currentPos,  // index of current chunk, in `input`
+        parser,
+        parsers,
+        rootFilename = env && env.filename;
 
     // Top parser on an import tree must be sure there is one "env"
     // which will then be passed around by reference.
@@ -76,115 +64,184 @@ less.Parser = function Parser(env) {
         queue: [],               // Files which haven't been imported yet
         files: env.files,        // Holds the imported parse trees
         contents: env.contents,  // Holds the imported file contents
+        contentsIgnoredChars: env.contentsIgnoredChars, // lines inserted, not in the original less
         mime:  env.mime,         // MIME type of .less files
         error: null,             // Error in parsing/evaluating an import
-        push: function (path, currentFileInfo, callback) {
-            var parserImporter = this;
+        push: function (path, currentFileInfo, importOptions, callback) {
+            var parserImports = this;
             this.queue.push(path);
 
-            //
-            // Import a file asynchronously
-            //
-            less.Parser.importer(path, currentFileInfo, function (e, root, fullPath) {
-                parserImporter.queue.splice(parserImporter.queue.indexOf(path), 1); // Remove the path from the queue
+            var fileParsedFunc = function (e, root, fullPath) {
+                parserImports.queue.splice(parserImports.queue.indexOf(path), 1); // Remove the path from the queue
 
-                var imported = fullPath in parserImporter.files;
+                var importedPreviously = fullPath in parserImports.files || fullPath === rootFilename;
 
-                parserImporter.files[fullPath] = root;                        // Store the root
+                parserImports.files[fullPath] = root;                        // Store the root
 
-                if (e && !parserImporter.error) { parserImporter.error = e; }
-                
-                callback(e, root, imported);
-            }, env);
+                if (e && !parserImports.error) { parserImports.error = e; }
+
+                callback(e, root, importedPreviously, fullPath);
+            };
+
+            if (less.Parser.importer) {
+                less.Parser.importer(path, currentFileInfo, fileParsedFunc, env);
+            } else {
+                less.Parser.fileLoader(path, currentFileInfo, function(e, contents, fullPath, newFileInfo) {
+                    if (e) {fileParsedFunc(e); return;}
+
+                    var newEnv = new tree.parseEnv(env);
+
+                    newEnv.currentFileInfo = newFileInfo;
+                    newEnv.processImports = false;
+                    newEnv.contents[fullPath] = contents;
+
+                    if (currentFileInfo.reference || importOptions.reference) {
+                        newFileInfo.reference = true;
+                    }
+
+                    if (importOptions.inline) {
+                        fileParsedFunc(null, contents, fullPath);
+                    } else {
+                        new(less.Parser)(newEnv).parse(contents, function (e, root) {
+                            fileParsedFunc(e, root, fullPath);
+                        });
+                    }
+                }, env);
+            }
         }
     };
 
-    function save()    { temp = chunks[j], memo = i, current = i; }
-    function restore() { chunks[j] = temp, i = memo, current = i; }
+    function save()    { temp = current; memo = currentPos = i; }
+    function restore() { current = temp; currentPos = i = memo; }
 
     function sync() {
-        if (i > current) {
-            chunks[j] = chunks[j].slice(i - current);
-            current = i;
+        if (i > currentPos) {
+            current = current.slice(i - currentPos);
+            currentPos = i;
         }
     }
-    function isWhitespace(c) {
-        // Could change to \s?
-        var code = c.charCodeAt(0);
-        return code === 32 || code === 10 || code === 9;
+    function isWhitespace(str, pos) {
+        var code = str.charCodeAt(pos | 0);
+        return (code <= 32) && (code === 32 || code === 10 || code === 9);
     }
     //
     // Parse from a token, regexp or string, and move forward if match
     //
     function $(tok) {
-        var match, args, length, index, k;
+        var tokType = typeof tok,
+            match, length;
 
+        // Either match a single character in the input,
+        // or match a regexp in the current chunk (`current`).
         //
-        // Non-terminal
-        //
-        if (tok instanceof Function) {
-            return tok.call(parser.parsers);
-        //
-        // Terminal
-        //
-        //     Either match a single character in the input,
-        //     or match a regexp in the current chunk (chunk[j]).
-        //
-        } else if (typeof(tok) === 'string') {
-            match = input.charAt(i) === tok ? tok : null;
-            length = 1;
-            sync ();
-        } else {
-            sync ();
-
-            if (match = tok.exec(chunks[j])) {
-                length = match[0].length;
-            } else {
+        if (tokType === "string") {
+            if (input.charAt(i) !== tok) {
                 return null;
             }
+            skipWhitespace(1);
+            return tok;
+        }
+
+        // regexp
+        sync ();
+        if (! (match = tok.exec(current))) {
+            return null;
         }
 
+        length = match[0].length;
+
         // The match is confirmed, add the match length to `i`,
         // and consume any extra white-space characters (' ' || '\n')
         // which come after that. The reason for this is that LeSS's
         // grammar is mostly white-space insensitive.
         //
-        if (match) {
-            skipWhitespace(length);
+        skipWhitespace(length);
 
-            if(typeof(match) === 'string') {
-                return match;
-            } else {
-                return match.length === 1 ? match[0] : match;
-            }
+        if(typeof(match) === 'string') {
+            return match;
+        } else {
+            return match.length === 1 ? match[0] : match;
         }
     }
 
+    // Specialization of $(tok)
+    function $re(tok) {
+        if (i > currentPos) {
+            current = current.slice(i - currentPos);
+            currentPos = i;
+        }
+        var m = tok.exec(current);
+        if (!m) {
+            return null;
+        }
+
+        skipWhitespace(m[0].length);
+        if(typeof m === "string") {
+            return m;
+        }
+
+        return m.length === 1 ? m[0] : m;
+    }
+
+    var _$re = $re;
+
+    // Specialization of $(tok)
+    function $char(tok) {
+        if (input.charAt(i) !== tok) {
+            return null;
+        }
+        skipWhitespace(1);
+        return tok;
+    }
+
     function skipWhitespace(length) {
         var oldi = i, oldj = j,
-            endIndex = i + chunks[j].length,
-            mem = i += length;
+            curr = i - currentPos,
+            endIndex = i + current.length - curr,
+            mem = (i += length),
+            inp = input,
+            c;
+
+        for (; i < endIndex; i++) {
+            c = inp.charCodeAt(i);
+            if (c > 32) {
+                break;
+            }
 
-        while (i < endIndex) {
-            if (! isWhitespace(input.charAt(i))) { break }
-            i++;
-        }
-        chunks[j] = chunks[j].slice(length + (i - mem));
-        current = i;
+            if ((c !== 32) && (c !== 10) && (c !== 9) && (c !== 13)) {
+                break;
+            }
+         }
+
+        current = current.slice(length + i - mem + curr);
+        currentPos = i;
 
-        if (chunks[j].length === 0 && j < chunks.length - 1) { j++ }
+        if (!current.length && (j < chunks.length - 1)) {
+            current = chunks[++j];
+            skipWhitespace(0); // skip space at the beginning of a chunk
+            return true; // things changed
+        }
 
         return oldi !== i || oldj !== j;
     }
 
     function expect(arg, msg) {
-        var result = $(arg);
-        if (! result) {
-            error(msg || (typeof(arg) === 'string' ? "expected '" + arg + "' got '" + input.charAt(i) + "'"
-                                                   : "unexpected token"));
-        } else {
+        // some older browsers return typeof 'function' for RegExp
+        var result = (Object.prototype.toString.call(arg) === '[object Function]') ? arg.call(parsers) : $(arg);
+        if (result) {
             return result;
         }
+        error(msg || (typeof(arg) === 'string' ? "expected '" + arg + "' got '" + input.charAt(i) + "'"
+                                               : "unexpected token"));
+    }
+
+    // Specialization of expect()
+    function expectChar(arg, msg) {
+        if (input.charAt(i) === arg) {
+            skipWhitespace(1);
+            return arg;
+        }
+        error(msg || "expected '" + arg + "' got '" + input.charAt(i) + "'");
     }
 
     function error(msg, type) {
@@ -200,14 +257,16 @@ less.Parser = function Parser(env) {
         if (typeof(tok) === 'string') {
             return input.charAt(i) === tok;
         } else {
-            if (tok.test(chunks[j])) {
-                return true;
-            } else {
-                return false;
-            }
+            return tok.test(current);
         }
     }
 
+    // Specialization of peek()
+    function peekChar(tok) {
+        return input.charAt(i) === tok;
+    }
+
+
     function getInput(e, env) {
         if (e.filename && env.currentFileInfo.filename && (e.filename !== env.currentFileInfo.filename)) {
             return parser.imports.contents[e.filename];
@@ -216,13 +275,23 @@ less.Parser = function Parser(env) {
         }
     }
 
-    function getLocation(index, input) {
-        for (var n = index, column = -1;
-                 n >= 0 && input.charAt(n) !== '\n';
-                 n--) { column++ }
+    function getLocation(index, inputStream) {
+        var n = index + 1,
+            line = null,
+            column = -1;
+
+        while (--n >= 0 && inputStream.charAt(n) !== '\n') {
+            column++;
+        }
 
-        return { line:   typeof(index) === 'number' ? (input.slice(0, index).match(/\n/g) || "").length : null,
-                 column: column };
+        if (typeof index === 'number') {
+            line = (inputStream.slice(0, index).match(/\n/g) || "").length;
+        }
+
+        return {
+            line: line,
+            column: column
+        };
     }
 
     function getDebugInfo(index, inputStream, env) {
@@ -242,6 +311,7 @@ less.Parser = function Parser(env) {
             loc = getLocation(e.index, input),
             line = loc.line,
             col  = loc.column,
+            callLine = e.call && getLocation(e.call, input).line,
             lines = input.split('\n');
 
         this.type = e.type || 'Syntax';
@@ -249,8 +319,8 @@ less.Parser = function Parser(env) {
         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);
-        this.callExtract = lines[getLocation(e.call, input).line];
+        this.callLine = callLine + 1;
+        this.callExtract = lines[callLine];
         this.stack = e.stack;
         this.column = col;
         this.extract = [
@@ -274,97 +344,167 @@ less.Parser = function Parser(env) {
     //
     // The Parser
     //
-    return parser = {
+    parser = {
 
         imports: imports,
         //
         // Parse an input string into an abstract syntax tree,
-        // call `callback` when done.
+        // @param str A string containing 'less' markup
+        // @param callback call `callback` when done.
+        // @param [additionalData] An optional map which can contains vars - a map (key, value) of variables to apply
         //
-        parse: function (str, callback) {
-            var root, start, end, zone, line, lines, buff = [], c, error = null;
+        parse: function (str, callback, additionalData) {
+            var root, line, lines, error = null, globalVars, modifyVars, preText = "";
+
+            i = j = currentPos = furthest = 0;
 
-            i = j = current = furthest = 0;
-            input = str.replace(/\r\n/g, '\n');
+            globalVars = (additionalData && additionalData.globalVars) ? less.Parser.serializeVars(additionalData.globalVars) + '\n' : '';
+            modifyVars = (additionalData && additionalData.modifyVars) ? '\n' + less.Parser.serializeVars(additionalData.modifyVars) : '';
+
+            if (globalVars || (additionalData && additionalData.banner)) {
+                preText = ((additionalData && additionalData.banner) ? additionalData.banner : "") + globalVars;
+                parser.imports.contentsIgnoredChars[env.currentFileInfo.filename] = preText.length;
+            }
 
+            str = str.replace(/\r\n/g, '\n');
             // Remove potential UTF Byte Order Mark
-            input = input.replace(/^\uFEFF/, '');
+            input = str = preText + str.replace(/^\uFEFF/, '') + modifyVars;
+            parser.imports.contents[env.currentFileInfo.filename] = str;
 
             // Split the input into chunks.
-            chunks = (function (chunks) {
-                var j = 0,
-                    skip = /(?:@\{[\w-]+\}|[^"'`\{\}\/\(\)\\])+/g,
-                    comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,
-                    string = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`]|\\.)*)`/g,
-                    level = 0,
-                    match,
-                    chunk = chunks[0],
-                    inParam;
-
-                for (var i = 0, c, cc; i < input.length;) {
-                    skip.lastIndex = i;
-                    if (match = skip.exec(input)) {
-                        if (match.index === i) {
-                            i += match[0].length;
-                            chunk.push(match[0]);
-                        }
+            chunks = (function (input) {
+                var len = input.length, level = 0, parenLevel = 0,
+                    lastOpening, lastOpeningParen, lastMultiComment, lastMultiCommentEndBrace,
+                    chunks = [], emitFrom = 0,
+                    parserCurrentIndex, currentChunkStartIndex, cc, cc2, matched;
+
+                function fail(msg, index) {
+                    error = new(LessError)({
+                        index: index || parserCurrentIndex,
+                        type: 'Parse',
+                        message: msg,
+                        filename: env.currentFileInfo.filename
+                    }, env);
+                }
+
+                function emitChunk(force) {
+                    var len = parserCurrentIndex - emitFrom;
+                    if (((len < 512) && !force) || !len) {
+                        return;
                     }
-                    c = input.charAt(i);
-                    comment.lastIndex = string.lastIndex = i;
+                    chunks.push(input.slice(emitFrom, parserCurrentIndex + 1));
+                    emitFrom = parserCurrentIndex + 1;
+                }
 
-                    if (match = string.exec(input)) {
-                        if (match.index === i) {
-                            i += match[0].length;
-                            chunk.push(match[0]);
-                            continue;
-                        }
+                for (parserCurrentIndex = 0; parserCurrentIndex < len; parserCurrentIndex++) {
+                    cc = input.charCodeAt(parserCurrentIndex);
+                    if (((cc >= 97) && (cc <= 122)) || (cc < 34)) {
+                        // a-z or whitespace
+                        continue;
                     }
 
-                    if (!inParam && c === '/') {
-                        cc = input.charAt(i + 1);
-                        if (cc === '/' || cc === '*') {
-                            if (match = comment.exec(input)) {
-                                if (match.index === i) {
-                                    i += match[0].length;
-                                    chunk.push(match[0]);
-                                    continue;
+                    switch (cc) {
+                        case 40:                        // (
+                            parenLevel++; 
+                            lastOpeningParen = parserCurrentIndex; 
+                            continue;
+                        case 41:                        // )
+                            if (--parenLevel < 0) {
+                                return fail("missing opening `(`");
+                            }
+                            continue;
+                        case 59:                        // ;
+                            if (!parenLevel) { emitChunk(); }
+                            continue;
+                        case 123:                       // {
+                            level++; 
+                            lastOpening = parserCurrentIndex; 
+                            continue;
+                        case 125:                       // }
+                            if (--level < 0) {
+                                return fail("missing opening `{`");
+                            }
+                            if (!level) { emitChunk(); }
+                            continue;
+                        case 92:                        // \
+                            if (parserCurrentIndex < len - 1) { parserCurrentIndex++; continue; }
+                            return fail("unescaped `\\`");
+                        case 34:
+                        case 39:
+                        case 96:                        // ", ' and `
+                            matched = 0;
+                            currentChunkStartIndex = parserCurrentIndex;
+                            for (parserCurrentIndex = parserCurrentIndex + 1; parserCurrentIndex < len; parserCurrentIndex++) {
+                                cc2 = input.charCodeAt(parserCurrentIndex);
+                                if (cc2 > 96) { continue; }
+                                if (cc2 == cc) { matched = 1; break; }
+                                if (cc2 == 92) {        // \
+                                    if (parserCurrentIndex == len - 1) {
+                                        return fail("unescaped `\\`");
+                                    }
+                                    parserCurrentIndex++;
                                 }
                             }
-                        }
-                    }
-                    
-                    switch (c) {
-                        case '{': if (! inParam) { level ++;        chunk.push(c);                           break }
-                        case '}': if (! inParam) { level --;        chunk.push(c); chunks[++j] = chunk = []; break }
-                        case '(': if (! inParam) { inParam = true;  chunk.push(c);                           break }
-                        case ')': if (  inParam) { inParam = false; chunk.push(c);                           break }
-                        default:                                    chunk.push(c);
+                            if (matched) { continue; }
+                            return fail("unmatched `" + String.fromCharCode(cc) + "`", currentChunkStartIndex);
+                        case 47:                        // /, check for comment
+                            if (parenLevel || (parserCurrentIndex == len - 1)) { continue; }
+                            cc2 = input.charCodeAt(parserCurrentIndex + 1);
+                            if (cc2 == 47) {
+                                // //, find lnfeed
+                                for (parserCurrentIndex = parserCurrentIndex + 2; parserCurrentIndex < len; parserCurrentIndex++) {
+                                    cc2 = input.charCodeAt(parserCurrentIndex);
+                                    if ((cc2 <= 13) && ((cc2 == 10) || (cc2 == 13))) { break; }
+                                }
+                            } else if (cc2 == 42) {
+                                // /*, find */
+                                lastMultiComment = currentChunkStartIndex = parserCurrentIndex;
+                                for (parserCurrentIndex = parserCurrentIndex + 2; parserCurrentIndex < len - 1; parserCurrentIndex++) {
+                                    cc2 = input.charCodeAt(parserCurrentIndex);
+                                    if (cc2 == 125) { lastMultiCommentEndBrace = parserCurrentIndex; }
+                                    if (cc2 != 42) { continue; }
+                                    if (input.charCodeAt(parserCurrentIndex + 1) == 47) { break; }
+                                }
+                                if (parserCurrentIndex == len - 1) {
+                                    return fail("missing closing `*/`", currentChunkStartIndex);
+                                }
+                                parserCurrentIndex++;
+                            }
+                            continue;
+                        case 42:                       // *, check for unmatched */
+                            if ((parserCurrentIndex < len - 1) && (input.charCodeAt(parserCurrentIndex + 1) == 47)) {
+                                return fail("unmatched `/*`");
+                            }
+                            continue;
                     }
-                    
-                    i++;
                 }
-                if (level != 0) {
-                    error = new(LessError)({
-                        index: i-1,
-                        type: 'Parse',
-                        message: (level > 0) ? "missing closing `}`" : "missing opening `{`",
-                        filename: env.currentFileInfo.filename
-                    }, env);
+
+                if (level !== 0) {
+                    if ((lastMultiComment > lastOpening) && (lastMultiCommentEndBrace > lastMultiComment)) {
+                        return fail("missing closing `}` or `*/`", lastOpening);
+                    } else {
+                        return fail("missing closing `}`", lastOpening);
+                    }
+                } else if (parenLevel !== 0) {
+                    return fail("missing closing `)`", lastOpeningParen);
                 }
 
-                return chunks.map(function (c) { return c.join('') });;
-            })([[]]);
+                emitChunk(true);
+                return chunks;
+            })(str);
 
             if (error) {
                 return callback(new(LessError)(error, env));
             }
 
+            current = chunks[0];
+
             // Start with the primary rule.
             // The whole syntax tree is held under a Ruleset node,
             // with the `root` property set to true, so no `{}` are
             // output. The callback is called when the input is parsed.
             try {
-                root = new(tree.Ruleset)([], $(this.parsers.primary));
+                root = new(tree.Ruleset)(null, this.parsers.primary());
                 root.root = true;
                 root.firstRoot = true;
             } catch (e) {
@@ -372,11 +512,10 @@ less.Parser = function Parser(env) {
             }
 
             root.toCSS = (function (evaluate) {
-                var line, lines, column;
-
                 return function (options, variables) {
                     options = options || {};
-                    var importError,
+                    var evaldRoot,
+                        css,
                         evalEnv = new tree.evalEnv(options);
                         
                     //
@@ -402,32 +541,85 @@ less.Parser = function Parser(env) {
                                 }
                                 value = new(tree.Value)([value]);
                             }
-                            return new(tree.Rule)('@' + k, value, false, 0);
+                            return new(tree.Rule)('@' + k, value, false, null, 0);
                         });
                         evalEnv.frames = [new(tree.Ruleset)(null, variables)];
                     }
 
                     try {
-                        var evaldRoot = evaluate.call(this, evalEnv);
+                        var preEvalVisitors = [],
+                            visitors = [
+                                new(tree.joinSelectorVisitor)(),
+                                new(tree.processExtendsVisitor)(),
+                                new(tree.toCSSVisitor)({compress: Boolean(options.compress)})
+                            ], i, root = this;
+
+                        if (options.plugins) {
+                            for(i =0; i < options.plugins.length; i++) {
+                                if (options.plugins[i].isPreEvalVisitor) {
+                                    preEvalVisitors.push(options.plugins[i]);
+                                } else {
+                                    if (options.plugins[i].isPreVisitor) {
+                                        visitors.splice(0, 0, options.plugins[i]);
+                                    } else {
+                                        visitors.push(options.plugins[i]);
+                                    }
+                                }
+                            }
+                        }
 
-                        new(tree.joinSelectorVisitor)()
-                            .run(evaldRoot);
+                        for(i = 0; i < preEvalVisitors.length; i++) {
+                            preEvalVisitors[i].run(root);
+                        }
+
+                        evaldRoot = evaluate.call(root, evalEnv);
 
-                        new(tree.processExtendsVisitor)()
-                            .run(evaldRoot);
+                        for(i = 0; i < visitors.length; i++) {
+                            visitors[i].run(evaldRoot);
+                        }
 
-                        var css = evaldRoot.toCSS({
+                        if (options.sourceMap) {
+                            evaldRoot = new tree.sourceMapOutput(
+                                {
+                                    contentsIgnoredCharsMap: parser.imports.contentsIgnoredChars,
+                                    writeSourceMap: options.writeSourceMap,
+                                    rootNode: evaldRoot,
+                                    contentsMap: parser.imports.contents,
+                                    sourceMapFilename: options.sourceMapFilename,
+                                    sourceMapURL: options.sourceMapURL,
+                                    outputFilename: options.sourceMapOutputFilename,
+                                    sourceMapBasepath: options.sourceMapBasepath,
+                                    sourceMapRootpath: options.sourceMapRootpath,
+                                    outputSourceFiles: options.outputSourceFiles,
+                                    sourceMapGenerator: options.sourceMapGenerator
+                                });
+                        }
+
+                        css = evaldRoot.toCSS({
                                 compress: Boolean(options.compress),
                                 dumpLineNumbers: env.dumpLineNumbers,
-                                strictUnits: Boolean(options.strictUnits)});
+                                strictUnits: Boolean(options.strictUnits),
+                                numPrecision: 8});
                     } catch (e) {
                         throw new(LessError)(e, env);
                     }
 
-                    if (options.yuicompress && less.mode === 'node') {
-                        return require('ycssmin').cssmin(css, options.maxLineLen);
+                    if (options.cleancss && less.mode === 'node') {
+                        var CleanCSS = require('clean-css'),
+                            cleancssOptions = options.cleancssOptions || {};
+
+                        if (cleancssOptions.keepSpecialComments === undefined) {
+                            cleancssOptions.keepSpecialComments = "*";
+                        }
+                        cleancssOptions.processImport = false;
+                        cleancssOptions.noRebase = true;
+                        if (cleancssOptions.noAdvanced === undefined) {
+                            cleancssOptions.noAdvanced = true;
+                        }
+
+                        return new CleanCSS(cleancssOptions).minify(css);
                     } else if (options.compress) {
-                        return css.replace(/(\s)+/g, "$1");
+                        return css.replace(/(^(\s)+)|((\s)+$)/g, "");
                     } else {
                         return css;
                     }
@@ -444,10 +636,9 @@ less.Parser = function Parser(env) {
             // and the part which didn't), so we can color them differently.
             if (i < input.length - 1) {
                 i = furthest;
+                var loc = getLocation(i, input);
                 lines = input.split('\n');
-                line = (input.slice(0, i).match(/\n/g) || "").length + 1;
-
-                for (var n = i, column = -1; n >= 0 && input.charAt(n) !== '\n'; n--) { column++ }
+                line = loc.line + 1;
 
                 error = {
                     type: "Parse",
@@ -455,7 +646,7 @@ less.Parser = function Parser(env) {
                     index: i,
                     filename: env.currentFileInfo.filename,
                     line: line,
-                    column: column,
+                    column: loc.column,
                     extract: [
                         lines[line - 2],
                         lines[line - 1],
@@ -472,10 +663,10 @@ less.Parser = function Parser(env) {
                         e = new(LessError)(e, env);
                     }
 
-                    callback(e);
+                    return callback(e);
                 }
                 else {
-                    callback(null, root);
+                    return callback(null, root);
                 }
             };
 
@@ -483,7 +674,7 @@ less.Parser = function Parser(env) {
                 new tree.importVisitor(this.imports, finish)
                     .run(root);
             } else {
-                finish();
+                return finish();
             }
         },
 
@@ -516,7 +707,7 @@ less.Parser = function Parser(env) {
         //  value is truly, will return a new node, of the relevant type. Sometimes, we need to check
         //  first, before parsing, that's when we use `peek()`.
         //
-        parsers: {
+        parsers: parsers = {
             //
             // The `primary` rule is the *entry* and *exit* point of the parser.
             // The rules here can appear at any level of the parse tree.
@@ -533,13 +724,21 @@ less.Parser = function Parser(env) {
             // block rule: at the root level.
             //
             primary: function () {
-                var node, root = [];
+                var mixin = this.mixin, $re = _$re, root = [], node;
 
-                while ((node = $(this.extendRule) || $(this.mixin.definition) || $(this.rule)    ||  $(this.ruleset) ||
-                               $(this.mixin.call)       || $(this.comment) ||  $(this.directive))
-                               || $(/^[\s\n]+/) || $(/^;+/)) {
-                    node && root.push(node);
+                while (current)
+                {
+                    node = this.extendRule() || mixin.definition() || this.rule() || this.ruleset() ||
+                        mixin.call() || this.comment() || this.directive();
+                    if (node) {
+                        root.push(node);
+                    } else {
+                        if (!($re(/^[\s\n]+/) || $re(/^;+/))) {
+                            break;
+                        }
+                    }
                 }
+
                 return root;
             },
 
@@ -549,13 +748,29 @@ less.Parser = function Parser(env) {
             comment: function () {
                 var comment;
 
-                if (input.charAt(i) !== '/') return;
+                if (input.charAt(i) !== '/') { return; }
 
                 if (input.charAt(i + 1) === '/') {
-                    return new(tree.Comment)($(/^\/\/.*/), true);
-                } else if (comment = $(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/)) {
-                    return new(tree.Comment)(comment);
+                    return new(tree.Comment)($re(/^\/\/.*/), true, i, env.currentFileInfo);
+                }
+                comment = $re(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/);
+                if (comment) {
+                    return new(tree.Comment)(comment, false, i, env.currentFileInfo);
+                }
+            },
+
+            comments: function () {
+                var comment, comments = [];
+
+                while(true) {
+                    comment = this.comment();
+                    if (!comment) {
+                        break;
+                    }
+                    comments.push(comment);
                 }
+
+                return comments;
             },
 
             //
@@ -570,12 +785,13 @@ less.Parser = function Parser(env) {
                 quoted: function () {
                     var str, j = i, e, index = i;
 
-                    if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
-                    if (input.charAt(j) !== '"' && input.charAt(j) !== "'") return;
+                    if (input.charAt(j) === '~') { j++; e = true; } // Escaped strings
+                    if (input.charAt(j) !== '"' && input.charAt(j) !== "'") { return; }
 
-                    e && $('~');
+                    if (e) { $char('~'); }
 
-                    if (str = $(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/)) {
+                    str = $re(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/);
+                    if (str) {
                         return new(tree.Quoted)(str[0], str[1] || str[2], e, index, env.currentFileInfo);
                     }
                 },
@@ -588,13 +804,13 @@ less.Parser = function Parser(env) {
                 keyword: function () {
                     var k;
 
-                    if (k = $(/^[_A-Za-z-][_A-Za-z0-9-]*/)) {
-                        if (tree.colors.hasOwnProperty(k)) {
-                            // detect named color
-                            return new(tree.Color)(tree.colors[k].slice(1));
-                        } else {
-                            return new(tree.Keyword)(k);
+                    k = $re(/^[_A-Za-z-][_A-Za-z0-9-]*/);
+                    if (k) {
+                        var color = tree.Color.fromKeyword(k);
+                        if (color) {
+                            return color;
                         }
+                        return new(tree.Keyword)(k);
                     }
                 },
 
@@ -611,26 +827,29 @@ less.Parser = function Parser(env) {
                 call: function () {
                     var name, nameLC, args, alpha_ret, index = i;
 
-                    if (! (name = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(chunks[j]))) return;
+                    name = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(current);
+                    if (!name) { return; }
 
                     name = name[1];
                     nameLC = name.toLowerCase();
+                    if (nameLC === 'url') {
+                        return null;
+                    }
 
-                    if (nameLC === 'url') { return null }
-                    else                  { i += name.length }
+                    i += name.length;
 
                     if (nameLC === 'alpha') {
-                        alpha_ret = $(this.alpha);
+                        alpha_ret = parsers.alpha();
                         if(typeof alpha_ret !== 'undefined') {
                             return alpha_ret;
                         }
                     }
 
-                    $('('); // Parse the '(' and consume whitespace.
+                    $char('('); // Parse the '(' and consume whitespace.
 
-                    args = $(this.entities.arguments);
+                    args = this.arguments();
 
-                    if (! $(')')) {
+                    if (! $char(')')) {
                         return;
                     }
 
@@ -639,17 +858,23 @@ less.Parser = function Parser(env) {
                 arguments: function () {
                     var args = [], arg;
 
-                    while (arg = $(this.entities.assignment) || $(this.expression)) {
+                    while (true) {
+                        arg = this.assignment() || parsers.expression();
+                        if (!arg) {
+                            break;
+                        }
                         args.push(arg);
-                        if (! $(',')) { break }
+                        if (! $char(',')) {
+                            break;
+                        }
                     }
                     return args;
                 },
                 literal: function () {
-                    return $(this.entities.dimension) ||
-                           $(this.entities.color) ||
-                           $(this.entities.quoted) ||
-                           $(this.entities.unicodeDescriptor);
+                    return this.dimension() ||
+                           this.color() ||
+                           this.quoted() ||
+                           this.unicodeDescriptor();
                 },
 
                 // Assignments are argument entities for calls.
@@ -660,7 +885,15 @@ less.Parser = function Parser(env) {
 
                 assignment: function () {
                     var key, value;
-                    if ((key = $(/^\w+(?=\s?=)/i)) && $('=') && (value = $(this.entity))) {
+                    key = $re(/^\w+(?=\s?=)/i);
+                    if (!key) {
+                        return;
+                    }
+                    if (!$char('=')) {
+                        return;
+                    }
+                    value = parsers.entity();
+                    if (value) {
                         return new(tree.Assignment)(key, value);
                     }
                 },
@@ -675,11 +908,14 @@ less.Parser = function Parser(env) {
                 url: function () {
                     var value;
 
-                    if (input.charAt(i) !== 'u' || !$(/^url\(/)) return;
-                    value = $(this.entities.quoted)  || $(this.entities.variable) ||
-                            $(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || "";
+                    if (input.charAt(i) !== 'u' || !$re(/^url\(/)) {
+                        return;
+                    }
+
+                    value = this.quoted() || this.variable() ||
+                            $re(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || "";
 
-                    expect(')');
+                    expectChar(')');
 
                     return new(tree.URL)((value.value != null || value instanceof tree.Variable)
                                         ? value : new(tree.Anonymous)(value), env.currentFileInfo);
@@ -696,16 +932,16 @@ less.Parser = function Parser(env) {
                 variable: function () {
                     var name, index = i;
 
-                    if (input.charAt(i) === '@' && (name = $(/^@@?[\w-]+/))) {
+                    if (input.charAt(i) === '@' && (name = $re(/^@@?[\w-]+/))) {
                         return new(tree.Variable)(name, index, env.currentFileInfo);
                     }
                 },
 
                 // A variable entity useing the protective {} e.g. @{var}
                 variableCurly: function () {
-                    var name, curly, index = i;
+                    var curly, index = i;
 
-                    if (input.charAt(i) === '@' && (curly = $(/^@\{([\w-]+)\}/))) {
+                    if (input.charAt(i) === '@' && (curly = $re(/^@\{([\w-]+)\}/))) {
                         return new(tree.Variable)("@" + curly[1], index, env.currentFileInfo);
                     }
                 },
@@ -720,7 +956,7 @@ less.Parser = function Parser(env) {
                 color: function () {
                     var rgb;
 
-                    if (input.charAt(i) === '#' && (rgb = $(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/))) {
+                    if (input.charAt(i) === '#' && (rgb = $re(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/))) {
                         return new(tree.Color)(rgb[1]);
                     }
                 },
@@ -733,9 +969,12 @@ less.Parser = function Parser(env) {
                 dimension: function () {
                     var value, c = input.charCodeAt(i);
                     //Is the first char of the dimension 0-9, '.', '+' or '-'
-                    if ((c > 57 || c < 43) || c === 47 || c == 44) return;
+                    if ((c > 57 || c < 43) || c === 47 || c == 44) {
+                        return;
+                    }
 
-                    if (value = $(/^([+-]?\d*\.?\d+)(%|[a-z]+)?/)) {
+                    value = $re(/^([+-]?\d*\.?\d+)(%|[a-z]+)?/);
+                    if (value) {
                         return new(tree.Dimension)(value[1], value[2]);
                     }
                 },
@@ -747,8 +986,9 @@ less.Parser = function Parser(env) {
                 //
                 unicodeDescriptor: function () {
                     var ud;
-                    
-                    if (ud = $(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/)) {
+
+                    ud = $re(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/);
+                    if (ud) {
                         return new(tree.UnicodeDescriptor)(ud[0]);
                     }
                 },
@@ -761,12 +1001,16 @@ less.Parser = function Parser(env) {
                 javascript: function () {
                     var str, j = i, e;
 
-                    if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
-                    if (input.charAt(j) !== '`') { return }
+                    if (input.charAt(j) === '~') { j++; e = true; } // Escaped strings
+                    if (input.charAt(j) !== '`') { return; }
+                    if (env.javascriptEnabled !== undefined && !env.javascriptEnabled) {
+                        error("You are using JavaScript, which has been disabled.");
+                    }
 
-                    e && $('~');
+                    if (e) { $char('~'); }
 
-                    if (str = $(/^`([^`]*)`/)) {
+                    str = $re(/^`([^`]*)`/);
+                    if (str) {
                         return new(tree.JavaScript)(str[1], i, e);
                     }
                 }
@@ -780,33 +1024,32 @@ less.Parser = function Parser(env) {
             variable: function () {
                 var name;
 
-                if (input.charAt(i) === '@' && (name = $(/^(@[\w-]+)\s*:/))) { return name[1] }
+                if (input.charAt(i) === '@' && (name = $re(/^(@[\w-]+)\s*:/))) { return name[1]; }
             },
 
             //
             // extend syntax - used to extend selectors
             //
             extend: function(isRule) {
-                var elements, e, index = i, option, extendList = [];
+                var elements, e, index = i, option, extendList, extend;
 
-                if (!$(isRule ? /^&:extend\(/ : /^:extend\(/)) { return; }
+                if (!(isRule ? $re(/^&:extend\(/) : $re(/^:extend\(/))) { return; }
 
                 do {
                     option = null;
-                    elements = [];
-                    while (true) {
-                        option = $(/^(all)(?=\s*(\)|,))/);
-                        if (option) { break; }
-                        e = $(this.element);
+                    elements = null;
+                    while (! (option = $re(/^(all)(?=\s*(\)|,))/))) {
+                        e = this.element();
                         if (!e) { break; }
-                        elements.push(e);
+                        if (elements) { elements.push(e); } else { elements = [ e ]; }
                     }
 
                     option = option && option[1];
 
-                    extendList.push(new(tree.Extend)(new(tree.Selector)(elements), option, index));
+                    extend = new(tree.Extend)(new(tree.Selector)(elements), option, index);
+                    if (extendList) { extendList.push(extend); } else { extendList = [ extend ]; }
 
-                } while($(","))
+                } while($char(","));
                 
                 expect(/^\)/);
 
@@ -840,52 +1083,62 @@ less.Parser = function Parser(env) {
                 // selector for now.
                 //
                 call: function () {
-                    var elements = [], e, c, args, delim, arg, index = i, s = input.charAt(i), important = false;
+                    var s = input.charAt(i), important = false, index = i, elemIndex,
+                        elements, elem, e, c, args;
 
-                    if (s !== '.' && s !== '#') { return }
+                    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]))+/)) {
-                        elements.push(new(tree.Element)(c, e, i));
-                        c = $('>');
-                    }
-                    if ($('(')) {
-                        args = this.mixin.args.call(this, true).args;
-                        expect(')');
+                    while (true) {
+                        elemIndex = i;
+                        e = $re(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/);
+                        if (!e) {
+                            break;
+                        }
+                        elem = new(tree.Element)(c, e, elemIndex, env.currentFileInfo);
+                        if (elements) { elements.push(elem); } else { elements = [ elem ]; }
+                        c = $char('>');
                     }
 
-                    args = args || [];
+                    if (elements) {
+                        if ($char('(')) {
+                            args = this.args(true).args;
+                            expectChar(')');
+                        }
 
-                    if ($(this.important)) {
-                        important = true;
-                    }
+                        if (parsers.important()) {
+                            important = true;
+                        }
 
-                    if (elements.length > 0 && ($(';') || peek('}'))) {
-                        return new(tree.mixin.Call)(elements, args, index, env.currentFileInfo, important);
+                        if (parsers.end()) {
+                            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};
+                    var parsers = parser.parsers, entities = parsers.entities,
+                        returner = { args:null, variadic: false },
+                        expressions = [], argsSemiColon = [], argsComma = [],
+                        isSemiColonSeperated, expressionContainsNamed, name, nameLoop, value, arg;
+
                     while (true) {
                         if (isCall) {
-                            arg = $(this.expression);
+                            arg = parsers.expression();
                         } else {
-                            $(this.comment);
-                            if (input.charAt(i) === '.' && $(/^\.{3}/)) {
+                            parsers.comments();
+                            if (input.charAt(i) === '.' && $re(/^\.{3}/)) {
                                 returner.variadic = true;
-                                if ($(";") && !isSemiColonSeperated) {
+                                if ($char(";") && !isSemiColonSeperated) {
                                     isSemiColonSeperated = true;
                                 }
                                 (isSemiColonSeperated ? argsSemiColon : argsComma)
                                     .push({ variadic: true });
                                 break;
                             }
-                            arg = $(this.entities.variable) || $(this.entities.literal)
-                                || $(this.entities.keyword);
+                            arg = entities.variable() || entities.literal() || entities.keyword();
                         }
 
                         if (!arg) {
@@ -902,25 +1155,25 @@ less.Parser = function Parser(env) {
                         if (isCall) {
                             // Variable
                             if (arg.value.length == 1) {
-                                var val = arg.value[0];
+                                val = arg.value[0];
                             }
                         } else {
                             val = arg;
                         }
 
                         if (val && val instanceof tree.Variable) {
-                            if ($(':')) {
+                            if ($char(':')) {
                                 if (expressions.length > 0) {
                                     if (isSemiColonSeperated) {
                                         error("Cannot mix ; and , as delimiter types");
                                     }
                                     expressionContainsNamed = true;
                                 }
-                                value = expect(this.expression);
+                                value = expect(parsers.expression);
                                 nameLoop = (name = val.name);
-                            } else if (!isCall && $(/^\.{3}/)) {
+                            } else if (!isCall && $re(/^\.{3}/)) {
                                 returner.variadic = true;
-                                if ($(";") && !isSemiColonSeperated) {
+                                if ($char(";") && !isSemiColonSeperated) {
                                     isSemiColonSeperated = true;
                                 }
                                 (isSemiColonSeperated ? argsSemiColon : argsComma)
@@ -938,11 +1191,11 @@ less.Parser = function Parser(env) {
 
                         argsComma.push({ name:nameLoop, value:value });
 
-                        if ($(',')) {
+                        if ($char(',')) {
                             continue;
                         }
 
-                        if ($(';') || isSemiColonSeperated) {
+                        if ($char(';') || isSemiColonSeperated) {
 
                             if (expressionContainsNamed) {
                                 error("Cannot mix ; and , as delimiter types");
@@ -951,7 +1204,7 @@ less.Parser = function Parser(env) {
                             isSemiColonSeperated = true;
 
                             if (expressions.length > 1) {
-                                value = new (tree.Value)(expressions);
+                                value = new(tree.Value)(expressions);
                             }
                             argsSemiColon.push({ name:name, value:value });
 
@@ -984,33 +1237,36 @@ less.Parser = function Parser(env) {
                 // the `{...}` block.
                 //
                 definition: function () {
-                    var name, params = [], match, ruleset, param, value, cond, variadic = false;
+                    var name, params = [], match, ruleset, cond, variadic = false;
                     if ((input.charAt(i) !== '.' && input.charAt(i) !== '#') ||
-                        peek(/^[^{]*\}/)) return;
+                        peek(/^[^{]*\}/)) {
+                        return;
+                    }
 
                     save();
 
-                    if (match = $(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/)) {
+                    match = $re(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/);
+                    if (match) {
                         name = match[1];
 
-                        var argInfo = this.mixin.args.call(this, false);
+                        var argInfo = this.args(false);
                         params = argInfo.args;
                         variadic = argInfo.variadic;
 
                         // .mixincall("@{a}");
                         // looks a bit like a mixin definition.. so we have to be nice and restore
-                        if (!$(')')) {
+                        if (!$char(')')) {
                             furthest = i;
                             restore();
                         }
                         
-                        $(this.comment);
+                        parsers.comments();
 
-                        if ($(/^when/)) { // Guard
-                            cond = expect(this.conditions, 'expected condition');
+                        if ($re(/^when/)) { // Guard
+                            cond = expect(parsers.conditions, 'expected condition');
                         }
 
-                        ruleset = $(this.block);
+                        ruleset = parsers.block();
 
                         if (ruleset) {
                             return new(tree.mixin.Definition)(name, params, ruleset, cond, variadic);
@@ -1026,9 +1282,11 @@ less.Parser = function Parser(env) {
             // and can be found inside a rule's value.
             //
             entity: function () {
-                return $(this.entities.literal) || $(this.entities.variable) || $(this.entities.url) ||
-                       $(this.entities.call)    || $(this.entities.keyword)  ||$(this.entities.javascript) ||
-                       $(this.comment);
+                var entities = this.entities;
+
+                return entities.literal() || entities.variable() || entities.url() ||
+                       entities.call()    || entities.keyword()  || entities.javascript() ||
+                       this.comment();
             },
 
             //
@@ -1037,7 +1295,7 @@ less.Parser = function Parser(env) {
             // it's there, if ';' was ommitted.
             //
             end: function () {
-                return $(';') || peek('}');
+                return $char(';') || peekChar('}');
             },
 
             //
@@ -1048,9 +1306,10 @@ less.Parser = function Parser(env) {
             alpha: function () {
                 var value;
 
-                if (! $(/^\(opacity=/i)) return;
-                if (value = $(/^\d+/) || $(this.entities.variable)) {
-                    expect(')');
+                if (! $re(/^\(opacity=/i)) { return; }
+                value = $re(/^\d+/) || this.entities.variable();
+                if (value) {
+                    expectChar(')');
                     return new(tree.Alpha)(value);
                 }
             },
@@ -1068,23 +1327,23 @@ less.Parser = function Parser(env) {
             // and an element name, such as a tag a class, or `*`.
             //
             element: function () {
-                var e, t, c, v;
+                var e, c, v, index = i;
 
-                c = $(this.combinator);
+                c = this.combinator();
 
-                e = $(/^(?:\d+\.\d+|\d+)%/) || $(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) ||
-                    $('*') || $('&') || $(this.attribute) || $(/^\([^()@]+\)/) || $(/^[\.#](?=@)/) || $(this.entities.variableCurly);
+                e = $re(/^(?:\d+\.\d+|\d+)%/) || $re(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) ||
+                    $char('*') || $char('&') || this.attribute() || $re(/^\([^()@]+\)/) || $re(/^[\.#](?=@)/) ||
+                    this.entities.variableCurly();
 
                 if (! e) {
-                    if ($('(')) {
-                        if ((v = ($(this.selector))) &&
-                                $(')')) {
+                    if ($char('(')) {
+                        if ((v = this.selector()) && $char(')')) {
                             e = new(tree.Paren)(v);
                         }
                     }
                 }
 
-                if (e) { return new(tree.Element)(c, e, i) }
+                if (e) { return new(tree.Element)(c, e, index, env.currentFileInfo); }
             },
 
             //
@@ -1098,18 +1357,28 @@ less.Parser = function Parser(env) {
             //
             combinator: function () {
                 var c = input.charAt(i);
-
-                if (c === '>' || c === '+' || c === '~' || c === '|') {
+                
+                if (c === '>' || c === '+' || c === '~' || c === '|' || c === '^') {
                     i++;
-                    while (input.charAt(i).match(/\s/)) { i++ }
+                    if (input.charAt(i) === '^') {
+                        c = '^^';
+                        i++;
+                    }
+                    while (isWhitespace(input, i)) { i++; }
                     return new(tree.Combinator)(c);
-                } else if (input.charAt(i - 1).match(/\s/)) {
+                } else if (isWhitespace(input, i - 1)) {
                     return new(tree.Combinator)(" ");
                 } else {
                     return new(tree.Combinator)(null);
                 }
             },
-
+            //
+            // A CSS selector (see selector below)
+            // with less extensions e.g. the ability to extend and guard
+            //
+            lessSelector: function () {
+                return this.selector(true);
+            },
             //
             // A CSS Selector
             //
@@ -1118,40 +1387,46 @@ less.Parser = function Parser(env) {
             //
             // Selectors are made out of one or more Elements, see above.
             //
-            selector: function () {
-                var sel, e, elements = [], c, extend, extendList = [];
-
-                while ((extend = $(this.extend)) || (e = $(this.element))) {
-                    if (extend) {
-                        extendList.push.apply(extendList, extend);
+            selector: function (isLess) {
+                var index = i, $re = _$re, elements, extendList, c, e, extend, when, condition;
+
+                while ((isLess && (extend = this.extend())) || (isLess && (when = $re(/^when/))) || (e = this.element())) {
+                    if (when) {
+                        condition = expect(this.conditions, 'expected condition');
+                    } else if (condition) {
+                        error("CSS guard can only be used at the end of selector");
+                    } else if (extend) {
+                        if (extendList) { extendList.push(extend); } else { extendList = [ extend ]; }
                     } else {
-                        if (extendList.length) {
-                            error("Extend can only be used at the end of selector");
-                        }
+                        if (extendList) { error("Extend can only be used at the end of selector"); }
                         c = input.charAt(i);
-                        elements.push(e)
+                        if (elements) { elements.push(e); } else { elements = [ e ]; }
                         e = null;
                     }
-                    if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') { break }
+                    if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') {
+                        break;
+                    }
                 }
 
-                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"); }
+                if (elements) { return new(tree.Selector)(elements, extendList, condition, index, env.currentFileInfo); }
+                if (extendList) { error("Extend must be used to extend a selector, it cannot be used on its own"); }
             },
             attribute: function () {
-                var attr = '', key, val, op;
+                if (! $char('[')) { return; }
 
-                if (! $('[')) return;
+                var entities = this.entities,
+                    key, val, op;
 
-                if (!(key = $(this.entities.variableCurly))) {
+                if (!(key = entities.variableCurly())) {
                     key = expect(/^(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/);
                 }
 
-                if ((op = $(/^[|~*$^]?=/))) {
-                    val = $(this.entities.quoted) || $(/^[\w-]+/) || $(this.entities.variableCurly);
+                op = $re(/^[|~*$^]?=/);
+                if (op) {
+                    val = entities.quoted() || $re(/^[0-9]+%/) || $re(/^[\w-]+/) || entities.variableCurly();
                 }
 
-                expect(']');
+                expectChar(']');
 
                 return new(tree.Attribute)(key, op, val);
             },
@@ -1162,7 +1437,7 @@ less.Parser = function Parser(env) {
             //
             block: function () {
                 var content;
-                if ($('{') && (content = $(this.primary)) && $('}')) {
+                if ($char('{') && (content = this.primary()) && $char('}')) {
                     return content;
                 }
             },
@@ -1171,24 +1446,36 @@ less.Parser = function Parser(env) {
             // div, .class, body > p {...}
             //
             ruleset: function () {
-                var selectors = [], s, rules, debugInfo;
+                var selectors, s, rules, debugInfo;
                 
                 save();
 
-                if (env.dumpLineNumbers)
+                if (env.dumpLineNumbers) {
                     debugInfo = getDebugInfo(i, input, env);
+                }
 
-                while (s = $(this.selector)) {
-                    selectors.push(s);
-                    $(this.comment);
-                    if (! $(',')) { break }
-                    $(this.comment);
+                while (true) {
+                    s = this.lessSelector();
+                    if (!s) {
+                        break;
+                    }
+                    if (selectors) { selectors.push(s); } else { selectors = [ s ]; }
+                    this.comments();
+                    if (s.condition && selectors.length > 1) {
+                        error("Guards are only currently allowed on a single selector.");
+                    }
+                    if (! $char(',')) { break; }
+                    if (s.condition) {
+                        error("Guards are only currently allowed on a single selector.");
+                    }
+                    this.comments();
                 }
 
-                if (selectors.length > 0 && (rules = $(this.block))) {
+                if (selectors && (rules = this.block())) {
                     var ruleset = new(tree.Ruleset)(selectors, rules, env.strictImports);
-                    if (env.dumpLineNumbers)
+                    if (env.dumpLineNumbers) {
                         ruleset.debugInfo = debugInfo;
+                    }
                     return ruleset;
                 } else {
                     // Backtrack
@@ -1197,22 +1484,28 @@ less.Parser = function Parser(env) {
                 }
             },
             rule: function (tryAnonymous) {
-                var name, value, c = input.charAt(i), important;
+                var name, value, c = input.charAt(i), important, merge = false;
                 save();
 
-                if (c === '.' || c === '#' || c === '&') { return }
+                if (c === '.' || c === '#' || c === '&') { return; }
 
-                if (name = $(this.variable) || $(this.property)) {
+                name = this.variable() || this.ruleProperty();
+                if (name) {
                     // 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));
+                    value = !tryAnonymous && (env.compress || (name.charAt && (name.charAt(0) === '@'))) ?
+                        (this.value() || this.anonymousValue()) :
+                        (this.anonymousValue() || this.value());
 
-                    important = $(this.important);
+                    important = this.important();
+                    
+                    // a name returned by this.ruleProperty() is always an array of the form:
+                    // [string-1, ..., string-n, ""] or [string-1, ..., string-n, "+"]
+                    // where each item is a tree.Keyword or tree.Variable
+                    merge = name.pop && (name.pop().value === "+");
 
-                    if (value && $(this.end)) {
-                        return new(tree.Rule)(name, value, important, memo, env.currentFileInfo);
+                    if (value && this.end()) {
+                        return new (tree.Rule)(name, value, important, merge, memo, env.currentFileInfo);
                     } else {
                         furthest = i;
                         restore();
@@ -1224,7 +1517,8 @@ less.Parser = function Parser(env) {
             },
             anonymousValue: function () {
                 var match;
-                if (match = /^([^@+\/'"*`(;{}-]*);/.exec(chunks[j])) {
+                match = /^([^@+\/'"*`(;{}-]*);/.exec(current);
+                if (match) {
                     i += match[0].length - 1;
                     return new(tree.Anonymous)(match[1]);
                 }
@@ -1245,13 +1539,13 @@ less.Parser = function Parser(env) {
 
                 save();
 
-                var dir = $(/^@import?\s+/);
+                var dir = $re(/^@import?\s+/);
 
-                var options = (dir ? $(this.importOptions) : null) || {};
+                var options = (dir ? this.importOptions() : null) || {};
 
-                if (dir && (path = $(this.entities.quoted) || $(this.entities.url))) {
-                    features = $(this.mediaFeatures);
-                    if ($(';')) {
+                if (dir && (path = this.entities.quoted() || this.entities.url())) {
+                    features = this.mediaFeatures();
+                    if ($char(';')) {
                         features = features && new(tree.Value)(features);
                         return new(tree.Import)(path, features, options, index, env.currentFileInfo);
                     }
@@ -1264,9 +1558,10 @@ less.Parser = function Parser(env) {
                 var o, options = {}, optionName, value;
 
                 // list of options, surrounded by parens
-                if (! $('(')) { return null; }
+                if (! $char('(')) { return null; }
                 do {
-                    if (o = $(this.importOption)) {
+                    o = this.importOption();
+                    if (o) {
                         optionName = o;
                         value = true;
                         switch(optionName) {
@@ -1280,38 +1575,38 @@ less.Parser = function Parser(env) {
                             break;
                         }
                         options[optionName] = value;
-                        if (! $(',')) { break }
+                        if (! $char(',')) { break; }
                     }
                 } while (o);
-                expect(')');
+                expectChar(')');
                 return options;
             },
 
             importOption: function() {
-                var opt = $(/^(less|css|multiple|once)/);
+                var opt = $re(/^(less|css|multiple|once|inline|reference)/);
                 if (opt) {
                     return opt[1];
                 }
             },
 
             mediaFeature: function () {
-                var e, p, nodes = [];
-
+                var entities = this.entities, nodes = [], e, p;
                 do {
-                    if (e = $(this.entities.keyword)) {
+                    e = entities.keyword() || entities.variable();
+                    if (e) {
                         nodes.push(e);
-                    } else if ($('(')) {
-                        p = $(this.property);
-                        e = $(this.value);
-                        if ($(')')) {
+                    } else if ($char('(')) {
+                        p = this.property();
+                        e = this.value();
+                        if ($char(')')) {
                             if (p && e) {
-                                nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, i, env.currentFileInfo, true)));
+                                nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, null, i, env.currentFileInfo, true)));
                             } else if (e) {
                                 nodes.push(new(tree.Paren)(e));
                             } else {
                                 return null;
                             }
-                        } else { return null }
+                        } else { return null; }
                     }
                 } while (e);
 
@@ -1321,16 +1616,19 @@ less.Parser = function Parser(env) {
             },
 
             mediaFeatures: function () {
-                var e, features = [];
-
+                var entities = this.entities, features = [], e;
                 do {
-                  if (e = $(this.mediaFeature)) {
-                      features.push(e);
-                      if (! $(',')) { break }
-                  } else if (e = $(this.entities.variable)) {
-                      features.push(e);
-                      if (! $(',')) { break }
-                  }
+                    e = this.mediaFeature();
+                    if (e) {
+                        features.push(e);
+                        if (! $char(',')) { break; }
+                    } else {
+                        e = entities.variable();
+                        if (e) {
+                            features.push(e);
+                            if (! $char(',')) { break; }
+                        }
+                    }
                 } while (e);
 
                 return features.length > 0 ? features : null;
@@ -1339,16 +1637,19 @@ less.Parser = function Parser(env) {
             media: function () {
                 var features, rules, media, debugInfo;
 
-                if (env.dumpLineNumbers)
+                if (env.dumpLineNumbers) {
                     debugInfo = getDebugInfo(i, input, env);
+                }
 
-                if ($(/^@media/)) {
-                    features = $(this.mediaFeatures);
+                if ($re(/^@media/)) {
+                    features = this.mediaFeatures();
 
-                    if (rules = $(this.block)) {
-                        media = new(tree.Media)(rules, features);
-                        if(env.dumpLineNumbers)
+                    rules = this.block();
+                    if (rules) {
+                        media = new(tree.Media)(rules, features, i, env.currentFileInfo);
+                        if (env.dumpLineNumbers) {
                             media.debugInfo = debugInfo;
+                        }
                         return media;
                     }
                 }
@@ -1360,20 +1661,21 @@ less.Parser = function Parser(env) {
             //     @charset "utf-8";
             //
             directive: function () {
-                var name, value, rules, identifier, e, nodes, nonVendorSpecificName,
-                    hasBlock, hasIdentifier, hasExpression;
+                var index = i, name, value, rules, nonVendorSpecificName,
+                    hasBlock, hasIdentifier, hasExpression, identifier;
 
-                if (input.charAt(i) !== '@') return;
+                if (input.charAt(i) !== '@') { return; }
 
-                if (value = $(this['import']) || $(this.media)) {
+                value = this['import']() || this.media();
+                if (value) {
                     return value;
                 }
 
                 save();
 
-                name = $(/^@[a-z-]+/);
+                name = $re(/^@[a-z-]+/);
                 
-                if (!name) return;
+                if (!name) { return; }
 
                 nonVendorSpecificName = name;
                 if (name.charAt(1) == '-' && name.indexOf('-', 2) > 0) {
@@ -1403,6 +1705,7 @@ less.Parser = function Parser(env) {
                     case "@right-bottom":
                         hasBlock = true;
                         break;
+                    case "@host":
                     case "@page":
                     case "@document":
                     case "@supports":
@@ -1416,17 +1719,21 @@ less.Parser = function Parser(env) {
                 }
 
                 if (hasIdentifier) {
-                    name += " " + ($(/^[^{]+/) || '').trim();
+                    identifier = ($re(/^[^{]+/) || '').trim();
+                    if (identifier) {
+                        name += " " + identifier;
+                    }
                 }
 
-                if (hasBlock)
-                {
-                    if (rules = $(this.block)) {
-                        return new(tree.Directive)(name, rules);
+                if (hasBlock) {
+                    rules = this.block();
+                    if (rules) {
+                        return new(tree.Directive)(name, rules, index, env.currentFileInfo);
                     }
                 } else {
-                    if ((value = hasExpression ? $(this.expression) : $(this.entity)) && $(';')) {
-                        var directive = new(tree.Directive)(name, value);
+                    value = hasExpression ? this.expression() : this.entity();
+                    if (value && $char(';')) {
+                        var directive = new(tree.Directive)(name, value, index, env.currentFileInfo);
                         if (env.dumpLineNumbers) {
                             directive.debugInfo = getDebugInfo(i, input, env);
                         }
@@ -1446,12 +1753,15 @@ less.Parser = function Parser(env) {
             // and before the `;`.
             //
             value: function () {
-                var e, expressions = [], important;
+                var e, expressions = [];
 
-                while (e = $(this.expression)) {
-                    expressions.push(e);
-                    if (! $(',')) { break }
-                }
+                do {
+                    e = this.expression();
+                    if (e) {
+                        expressions.push(e);
+                        if (! $char(',')) { break; }
+                    }
+                } while(e);
 
                 if (expressions.length > 0) {
                     return new(tree.Value)(expressions);
@@ -1459,48 +1769,66 @@ less.Parser = function Parser(env) {
             },
             important: function () {
                 if (input.charAt(i) === '!') {
-                    return $(/^! *important/);
+                    return $re(/^! *important/);
                 }
             },
             sub: function () {
                 var a, e;
 
-                if ($('(')) {
-                    if (a = $(this.addition)) {
+                if ($char('(')) {
+                    a = this.addition();
+                    if (a) {
                         e = new(tree.Expression)([a]);
-                        expect(')');
+                        expectChar(')');
                         e.parens = true;
                         return e;
                     }
                 }
             },
             multiplication: function () {
-                var m, a, op, operation, isSpaced, expression = [];
-                if (m = $(this.operand)) {
-                    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 {
+                var m, a, op, operation, isSpaced;
+                m = this.operand();
+                if (m) {
+                    isSpaced = isWhitespace(input, i - 1);
+                    while (true) {
+                        if (peek(/^\/[*\/]/)) {
                             break;
                         }
+                        op = $char('/') || $char('*');
+
+                        if (!op) { break; }
+
+                        a = this.operand();
+
+                        if (!a) { break; }
+
+                        m.parensInOp = true;
+                        a.parensInOp = true;
+                        operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
+                        isSpaced = isWhitespace(input, i - 1);
                     }
                     return operation || m;
                 }
             },
             addition: function () {
                 var m, a, op, operation, isSpaced;
-                if (m = $(this.multiplication)) {
-                    isSpaced = isWhitespace(input.charAt(i - 1));
-                    while ((op = $(/^[-+]\s+/) || (!isSpaced && ($('+') || $('-')))) &&
-                           (a = $(this.multiplication))) {
+                m = this.multiplication();
+                if (m) {
+                    isSpaced = isWhitespace(input, i - 1);
+                    while (true) {
+                        op = $re(/^[-+]\s+/) || (!isSpaced && ($char('+') || $char('-')));
+                        if (!op) {
+                            break;
+                        }
+                        a = this.multiplication();
+                        if (!a) {
+                            break;
+                        }
+                        
                         m.parensInOp = true;
                         a.parensInOp = true;
                         operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
-                        isSpaced = isWhitespace(input.charAt(i - 1));
+                        isSpaced = isWhitespace(input, i - 1);
                     }
                     return operation || m;
                 }
@@ -1508,21 +1836,33 @@ less.Parser = function Parser(env) {
             conditions: function () {
                 var a, b, index = i, condition;
 
-                if (a = $(this.condition)) {
-                    while ($(',') && (b = $(this.condition))) {
+                a = this.condition();
+                if (a) {
+                    while (true) {
+                        if (!peek(/^,\s*(not\s*)?\(/) || !$char(',')) {
+                            break;
+                        }
+                        b = this.condition();
+                        if (!b) {
+                            break;
+                        }
                         condition = new(tree.Condition)('or', condition || a, b, index);
                     }
                     return condition || a;
                 }
             },
             condition: function () {
-                var a, b, c, op, index = i, negate = false;
-
-                if ($(/^not/)) { negate = true }
-                expect('(');
-                if (a = $(this.addition) || $(this.entities.keyword) || $(this.entities.quoted)) {
-                    if (op = $(/^(?:>=|=<|[<=>])/)) {
-                        if (b = $(this.addition) || $(this.entities.keyword) || $(this.entities.quoted)) {
+                var entities = this.entities, index = i, negate = false,
+                    a, b, c, op;
+
+                if ($re(/^not/)) { negate = true; }
+                expectChar('(');
+                a = this.addition() || entities.keyword() || entities.quoted();
+                if (a) {
+                    op = $re(/^(?:>=|<=|=<|[<=>])/);
+                    if (op) {
+                        b = this.addition() || entities.keyword() || entities.quoted();
+                        if (b) {
                             c = new(tree.Condition)(op, a, b, index, negate);
                         } else {
                             error('expected expression');
@@ -1530,8 +1870,8 @@ less.Parser = function Parser(env) {
                     } else {
                         c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, negate);
                     }
-                    expect(')');
-                    return $(/^and/) ? new(tree.Condition)('and', c, $(this.condition)) : c;
+                    expectChar(')');
+                    return $re(/^and/) ? new(tree.Condition)('and', c, this.condition()) : c;
                 }
             },
 
@@ -1540,12 +1880,13 @@ less.Parser = function Parser(env) {
             // such as a Color, or a Variable
             //
             operand: function () {
-                var negate, p = input.charAt(i + 1);
+                var entities = this.entities,
+                    p = input.charAt(i + 1), negate;
 
-                if (input.charAt(i) === '-' && (p === '@' || p === '(')) { negate = $('-') }
-                var o = $(this.sub) || $(this.entities.dimension) ||
-                        $(this.entities.color) || $(this.entities.variable) ||
-                        $(this.entities.call);
+                if (input.charAt(i) === '-' && (p === '@' || p === '(')) { negate = $char('-'); }
+                var o = this.sub() || entities.dimension() ||
+                        entities.color() || entities.variable() ||
+                        entities.call();
 
                 if (negate) {
                     o.parensInOp = true;
@@ -1563,49 +1904,78 @@ less.Parser = function Parser(env) {
             //     @var * 2
             //
             expression: function () {
-                var e, delim, entities = [], d;
+                var entities = [], e, delim;
 
-                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));
+                do {
+                    e = this.addition() || this.entity();
+                    if (e) {
+                        entities.push(e);
+                        // operations do not allow keyword "/" dimension (e.g. small/20px) so we support that here
+                        if (!peek(/^\/[\/*]/)) {
+                            delim = $char('/');
+                            if (delim) {
+                                entities.push(new(tree.Anonymous)(delim));
+                            }
+                        }
                     }
-                }
+                } while (e);
                 if (entities.length > 0) {
                     return new(tree.Expression)(entities);
                 }
             },
             property: function () {
-                var name;
-
-                if (name = $(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/)) {
+                var name = $re(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/);
+                if (name) {
                     return name[1];
                 }
+            },
+            ruleProperty: function () {
+                var c = current, name = [], index = [], length = 0, s, k;
+                
+                function match(re) {
+                    var a = re.exec(c);
+                    if (a) {
+                        index.push(i + length);
+                        length += a[0].length;
+                        c = c.slice(a[1].length);
+                        return name.push(a[1]);
+                    }
+                }
+
+                match(/^(\*?)/);
+                while (match(/^((?:[\w-]+)|(?:@\{[\w-]+\}))/)); // !
+                if ((name.length > 1) && match(/^\s*(\+?)\s*:/)) {
+                    // at last, we have the complete match now. move forward, 
+                    // convert name particles to tree objects and return:
+                    skipWhitespace(length);
+                    if (name[0] === '') {
+                        name.shift();
+                        index.shift();
+                    }
+                    for (k = 0; k < name.length; k++) {
+                        s = name[k];
+                        name[k] = (s.charAt(0) !== '@')
+                            ? new(tree.Keyword)(s)
+                            : new(tree.Variable)('@' + s.slice(2, -1), 
+                                index[k], env.currentFileInfo);
+                    }
+                    return name;
+                }
             }
         }
     };
+    return parser;
 };
-
-if (less.mode === 'browser' || less.mode === 'rhino') {
-    //
-    // Used by `@import` directives
-    //
-    less.Parser.importer = function (path, currentFileInfo, callback, env) {
-        if (!/^([a-z-]+:)?\//.test(path) && currentFileInfo.currentDirectory) {
-            path = currentFileInfo.currentDirectory + path;
+less.Parser.serializeVars = function(vars) {
+    var s = '';
+
+    for (var name in vars) {
+        if (Object.hasOwnProperty.call(vars, name)) {
+            var value = vars[name];
+            s += ((name[0] === '@') ? '' : '@') + name +': '+ value +
+                    ((('' + value).slice(-1) === ';') ? '' : ';');
         }
-        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(sheetEnv,
-            function (e, root, data, sheet, _, path) {
-                callback.call(null, e, root, path);
-            }, true);
-    };
-}
+    }
 
+    return s;
+};