less 2.0.8 → 2.0.9

data/lib/less/js/lib/less/functions.js

@@ -144,20 +144,63 @@ tree.functions = {
         return new(tree.Quoted)('"' + str + '"', str);
     },
     round: function (n) {
+        return this._math('round', n);
+    },
+    ceil: function (n) {
+        return this._math('ceil', n);
+    },
+    floor: function (n) {
+        return this._math('floor', n);
+    },
+    _math: function (fn, n) {
         if (n instanceof tree.Dimension) {
-            return new(tree.Dimension)(Math.round(number(n)), n.unit);
+            return new(tree.Dimension)(Math[fn](number(n)), n.unit);
         } else if (typeof(n) === 'number') {
-            return Math.round(n);
+            return Math[fn](n);
         } else {
-	    throw {
-                error: "RuntimeError",
-                message: "math functions take numbers as parameters"
-            };
+            throw { type: "Argument", message: "argument must be a number" };
         }
     },
     argb: function (color) {
         return new(tree.Anonymous)(color.toARGB());
 
+    },
+    percentage: function (n) {
+        return new(tree.Dimension)(n.value * 100, '%');
+    },
+    color: function (n) {
+        if (n instanceof tree.Quoted) {
+            return new(tree.Color)(n.value.slice(1));
+        } else {
+            throw { type: "Argument", message: "argument must be a string" };
+        }
+    },
+    iscolor: function (n) {
+        return this._isa(n, tree.Color);
+    },
+    isnumber: function (n) {
+        return this._isa(n, tree.Dimension);
+    },
+    isstring: function (n) {
+        return this._isa(n, tree.Quoted);
+    },
+    iskeyword: function (n) {
+        return this._isa(n, tree.Keyword);
+    },
+    isurl: function (n) {
+        return this._isa(n, tree.URL);
+    },
+    ispixel: function (n) {
+        return (n instanceof tree.Dimension) && n.unit === 'px' ? tree.True : tree.False;
+    },
+    ispercentage: function (n) {
+        return (n instanceof tree.Dimension) && n.unit === '%' ? tree.True : tree.False;
+    },
+    isem: function (n) {
+        return (n instanceof tree.Dimension) && n.unit === 'em' ? tree.True : tree.False;
+    },
+    _isa: function (n, Type) {
+        return (n instanceof Type) ? tree.True : tree.False;
     }
 };
 

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

@@ -3,7 +3,7 @@ var path = require('path'),
     fs = require('fs');
 
 var less = {
-    version: [1, 1, 5],
+    version: [1, 2, 1],
     Parser: require('./parser').Parser,
     importer: require('./parser').importer,
     tree: require('./tree'),
@@ -43,7 +43,9 @@ var less = {
 
         if (options.silent) { return }
 
-        if (!ctx.index) {
+        if (ctx.stack) { return sys.error(stylize(ctx.stack, 'red')) }
+
+        if (!ctx.hasOwnProperty('index')) {
             return sys.error(ctx.stack || ctx.message);
         }
 
@@ -51,17 +53,20 @@ var less = {
             error.push(stylize((ctx.line - 1) + ' ' + extract[0], 'grey'));
         }
 
-        error.push(ctx.line + ' ' + extract[1].slice(0, ctx.column)
-                            + stylize(stylize(extract[1][ctx.column], 'bold')
-                            + extract[1].slice(ctx.column + 1), 'yellow'));
+        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[2]) === 'string') {
             error.push(stylize((ctx.line + 1) + ' ' + extract[2], 'grey'));
         }
         error = error.join('\n') + '\033[0m\n';
 
-        message += stylize(ctx.message, 'red');
-        ctx.filename && (message += stylize(' in ', 'red') + ctx.filename);
+        message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
+        ctx.filename && (message += stylize(' in ', 'red') + ctx.filename +
+                stylize(':' + ctx.line + ':' + ctx.column, 'grey'));
 
         sys.error(message, error);
 
@@ -69,16 +74,15 @@ var less = {
             sys.error(stylize('from ', 'red')       + (ctx.filename || ''));
             sys.error(stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract);
         }
-        if (ctx.stack) { sys.error(stylize(ctx.stack, 'red')) }
     }
 };
 
-['color',      'directive', 'operation',  'dimension',
- 'keyword',    'variable',  'ruleset',    'element',
- 'selector',   'quoted',    'expression', 'rule',
- 'call',       'url',       'alpha',      'import',
- 'mixin',      'comment',   'anonymous',  'value',
- 'javascript', 'assignment'
+['color',      'directive',  'operation',  'dimension',
+ 'keyword',    'variable',   'ruleset',    'element',
+ 'selector',   'quoted',     'expression', 'rule',
+ 'call',       'url',        'alpha',      'import',
+ 'mixin',      'comment',    'anonymous',  'value',
+ 'javascript', 'assignment', 'condition',  'paren'
 ].forEach(function (n) {
     require('./tree/' + n);
 });
@@ -106,17 +110,16 @@ less.Parser.importer = function (file, paths, callback) {
               paths: [path.dirname(pathname)].concat(paths),
               filename: pathname
           }).parse(data, function (e, root) {
-              if (e) less.writeError(e);
-              callback(root);
+              callback(e, root, data);
           });
         });
     } else {
-        sys.error("file '" + file + "' wasn't found.\n");
-        process.exit(1);
+        callback({ type: 'File', message: "'" + file + "' wasn't found.\n" });
     }
 }
 
 require('./functions');
+require('./colors');
 
 for (var k in less) { exports[k] = less[k] }
 

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

@@ -3,7 +3,8 @@ var less, tree;
 if (typeof environment === "object" && ({}).toString.call(environment) === "[object Environment]") {
     // Rhino
     // Details on how to detect Rhino: https://github.com/ringo/ringojs/issues/88
-    less = {};
+    if (typeof(window) === 'undefined') { less = {} }
+    else                                { less = window.less = {} }
     tree = less.tree = {};
     less.mode = 'rhino';
 } else if (typeof(window) === 'undefined') {
@@ -72,7 +73,9 @@ less.Parser = function Parser(env) {
         paths: env && env.paths || [],  // Search paths, when importing
         queue: [],                      // Files which haven't been imported yet
         files: {},                      // Holds the imported parse trees
+        contents: {},                   // Holds the imported file contents
         mime:  env && env.mime,         // MIME type of .less files
+        error: null,                    // Error in parsing/evaluating an import
         push: function (path, callback) {
             var that = this;
             this.queue.push(path);
@@ -80,11 +83,13 @@ less.Parser = function Parser(env) {
             //
             // Import a file asynchronously
             //
-            less.Parser.importer(path, this.paths, function (root) {
+            less.Parser.importer(path, this.paths, function (e, root, contents) {
                 that.queue.splice(that.queue.indexOf(path), 1); // Remove the path from the queue
                 that.files[path] = root;                        // Store the root
+                that.contents[path] = contents;
 
-                callback(root);
+                if (e && !that.error) { that.error = e }
+                callback(e, root);
 
                 if (that.queue.length === 0) { finish() }       // Call `finish` if we're done importing
             }, env);
@@ -158,6 +163,20 @@ less.Parser = function Parser(env) {
         }
     }
 
+    function expect(arg, msg) {
+        var result = $(arg);
+        if (! result) {
+            error(msg || (typeof(arg) === 'string' ? "expected '" + arg + "' got '" + input.charAt(i) + "'"
+                                                   : "unexpected token"));
+        } else {
+            return result;
+        }
+    }
+
+    function error(msg, type) {
+        throw { index: i, type: type || 'Syntax', message: msg };
+    }
+
     // Same as $(), but don't change the state of the parser,
     // just return the match.
     function peek(tok) {
@@ -172,6 +191,46 @@ less.Parser = function Parser(env) {
         }
     }
 
+    function getInput(e, env) {
+        if (e.filename && env.filename && (e.filename !== env.filename)) {
+            return parser.imports.contents[e.filename];
+        } else {
+            return input;
+        }
+    }
+
+    function getLocation(index, input) {
+        for (var n = index, column = -1;
+                 n >= 0 && input.charAt(n) !== '\n';
+                 n--) { column++ }
+
+        return { line:   typeof(index) === 'number' ? (input.slice(0, index).match(/\n/g) || "").length : null,
+                 column: column };
+    }
+
+    function LessError(e, env) {
+        var input = getInput(e, env),
+            loc = getLocation(e.index, input),
+            line = loc.line,
+            col  = loc.column,
+            lines = input.split('\n');
+
+        this.type = e.type || 'Syntax';
+        this.message = e.message;
+        this.filename = e.filename || env.filename;
+        this.index = e.index;
+        this.line = typeof(line) === 'number' ? line + 1 : null;
+        this.callLine = e.call && (getLocation(e.call, input) + 1);
+        this.callExtract = lines[getLocation(e.call, input)];
+        this.stack = e.stack;
+        this.column = col;
+        this.extract = [
+            lines[line - 1],
+            lines[line],
+            lines[line + 1]
+        ];
+    }
+
     this.env = env = env || {};
 
     // The optimization level dictates the thoroughness of the parser,
@@ -196,19 +255,18 @@ less.Parser = function Parser(env) {
             var root, start, end, zone, line, lines, buff = [], c, error = null;
 
             i = j = current = furthest = 0;
-            chunks = [];
             input = str.replace(/\r\n/g, '\n');
 
             // Split the input into chunks.
             chunks = (function (chunks) {
                 var j = 0,
-                    skip = /[^"'`\{\}\/\(\)]+/g,
+                    skip = /[^"'`\{\}\/\(\)\\]+/g,
                     comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,
+                    string = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`\\\r\n]|\\.)*)`/g,
                     level = 0,
                     match,
                     chunk = chunks[0],
-                    inParam,
-                    inString;
+                    inParam;
 
                 for (var i = 0, c, cc; i < input.length; i++) {
                     skip.lastIndex = i;
@@ -219,9 +277,17 @@ less.Parser = function Parser(env) {
                         }
                     }
                     c = input.charAt(i);
-                    comment.lastIndex = i;
+                    comment.lastIndex = string.lastIndex = i;
+
+                    if (match = string.exec(input)) {
+                        if (match.index === i) {
+                            i += match[0].length;
+                            chunk.push(match[0]);
+                            c = input.charAt(i);
+                        }
+                    }
 
-                    if (!inString && !inParam && c === '/') {
+                    if (!inParam && c === '/') {
                         cc = input.charAt(i + 1);
                         if (cc === '/' || cc === '*') {
                             if (match = comment.exec(input)) {
@@ -234,34 +300,21 @@ less.Parser = function Parser(env) {
                         }
                     }
 
-                    if        (c === '{' && !inString && !inParam) { level ++;
-                        chunk.push(c);
-                    } else if (c === '}' && !inString && !inParam) { level --;
-                        chunk.push(c);
-                        chunks[++j] = chunk = [];
-                    } else if (c === '(' && !inString && !inParam) {
-                        chunk.push(c);
-                        inParam = true;
-                    } else if (c === ')' && !inString && inParam) {
-                        chunk.push(c);
-                        inParam = false;
-                    } else {
-                        if (c === '"' || c === "'" || c === '`') {
-                            if (! inString) {
-                                inString = c;
-                            } else {
-                                inString = inString === c ? false : inString;
-                            }
-                        }
-                        chunk.push(c);
+                    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 (level > 0) {
-                    throw {
-                        type: 'Syntax',
-                        message: "Missing closing `}`",
+                    return callback(new(LessError)({
+                        index: i,
+                        type: 'Parse',
+                        message: "missing closing `}`",
                         filename: env.filename
-                    };
+                    }, env));
                 }
 
                 return chunks.map(function (c) { return c.join('') });;
@@ -271,14 +324,18 @@ less.Parser = function Parser(env) {
             // 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.
-            root = new(tree.Ruleset)([], $(this.parsers.primary));
-            root.root = true;
+            try {
+                root = new(tree.Ruleset)([], $(this.parsers.primary));
+                root.root = true;
+            } catch (e) {
+                return callback(new(LessError)(e, env));
+            }
 
             root.toCSS = (function (evaluate) {
                 var line, lines, column;
 
                 return function (options, variables) {
-                    var frames = [];
+                    var frames = [], importError;
 
                     options = options || {};
                     //
@@ -313,39 +370,21 @@ less.Parser = function Parser(env) {
                         var css = evaluate.call(this, { frames: frames })
                                           .toCSS([], { compress: options.compress || false });
                     } catch (e) {
-                        lines = input.split('\n');
-                        line = getLine(e.index);
-
-                        for (var n = e.index, column = -1;
-                                 n >= 0 && input.charAt(n) !== '\n';
-                                 n--) { column++ }
-
-                        throw {
-                            type: e.type,
-                            message: e.message,
-                            filename: env.filename,
-                            index: e.index,
-                            line: typeof(line) === 'number' ? line + 1 : null,
-                            callLine: e.call && (getLine(e.call) + 1),
-                            callExtract: lines[getLine(e.call)],
-                            stack: e.stack,
-                            column: column,
-                            extract: [
-                                lines[line - 1],
-                                lines[line],
-                                lines[line + 1]
-                            ]
-                        };
+                        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.compress) {
+
+                    if (options.yuicompress && less.mode === 'node') {
+                        return require('./cssmin').compressor.cssmin(css);
+                    } else if (options.compress) {
                         return css.replace(/(\s)+/g, "$1");
                     } else {
                         return css;
                     }
-
-                    function getLine(index) {
-                        return index ? (input.slice(0, index).match(/\n/g) || "").length : null;
-                    }
                 };
             })(root.eval);
 
@@ -365,7 +404,7 @@ less.Parser = function Parser(env) {
                 for (var n = i, column = -1; n >= 0 && input.charAt(n) !== '\n'; n--) { column++ }
 
                 error = {
-                    name: "ParseError",
+                    type: "Parse",
                     message: "Syntax Error on line " + line,
                     index: i,
                     filename: env.filename,
@@ -486,7 +525,15 @@ less.Parser = function Parser(env) {
                 //
                 keyword: function () {
                     var k;
-                    if (k = $(/^[_A-Za-z-][_A-Za-z0-9-]*/)) { return new(tree.Keyword)(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);
+                        }
+                    }
                 },
 
                 //
@@ -517,7 +564,7 @@ less.Parser = function Parser(env) {
 
                     if (! $(')')) return;
 
-                    if (name) { return new(tree.Call)(name, args, index) }
+                    if (name) { return new(tree.Call)(name, args, index, env.filename) }
                 },
                 arguments: function () {
                     var args = [], arg;
@@ -560,7 +607,8 @@ less.Parser = function Parser(env) {
                     if (input.charAt(i) !== 'u' || !$(/^url\(/)) return;
                     value = $(this.entities.quoted)  || $(this.entities.variable) ||
                             $(this.entities.dataURI) || $(/^[-\w%@$\/.&=:;#+?~]+/) || "";
-                    if (! $(')')) throw new(Error)("missing closing ) for url()");
+
+                    expect(')');
 
                     return new(tree.URL)((value.value || value.data || value instanceof tree.Variable)
                                         ? value : new(tree.Anonymous)(value), imports.paths);
@@ -592,7 +640,7 @@ less.Parser = function Parser(env) {
                     var name, index = i;
 
                     if (input.charAt(i) === '@' && (name = $(/^@@?[\w-]+/))) {
-                        return new(tree.Variable)(name, index);
+                        return new(tree.Variable)(name, index, env.filename);
                     }
                 },
 
@@ -620,7 +668,7 @@ less.Parser = function Parser(env) {
                     var value, c = input.charCodeAt(i);
                     if ((c > 57 || c < 45) || c === 47) return;
 
-                    if (value = $(/^(-?\d*\.?\d+)(px|%|em|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn)?/)) {
+                    if (value = $(/^(-?\d*\.?\d+)(px|%|em|rem|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn)?/)) {
                         return new(tree.Dimension)(value[1], value[2]);
                     }
                 },
@@ -688,7 +736,7 @@ less.Parser = function Parser(env) {
                 // selector for now.
                 //
                 call: function () {
-                    var elements = [], e, c, args, index = i, s = input.charAt(i);
+                    var elements = [], e, c, args, index = i, s = input.charAt(i), important = false;
 
                     if (s !== '.' && s !== '#') { return }
 
@@ -698,8 +746,12 @@ less.Parser = function Parser(env) {
                     }
                     $('(') && (args = $(this.entities.arguments)) && $(')');
 
+                    if ($(this.important)) {
+                        important = true;
+                    }
+
                     if (elements.length > 0 && ($(';') || peek('}'))) {
-                        return new(tree.mixin.Call)(elements, args, index);
+                        return new(tree.mixin.Call)(elements, args, index, env.filename, important);
                     }
                 },
 
@@ -723,11 +775,12 @@ less.Parser = function Parser(env) {
                 // the `{...}` block.
                 //
                 definition: function () {
-                    var name, params = [], match, ruleset, param, value;
-
+                    var name, params = [], match, ruleset, param, value, cond;
                     if ((input.charAt(i) !== '.' && input.charAt(i) !== '#') ||
                         peek(/^[^{]*(;|})/)) return;
 
+                    save();
+
                     if (match = $(/^([#.](?:[\w-]|\\(?:[a-fA-F0-9]{1,6} ?|[^a-fA-F0-9]))+)\s*\(/)) {
                         name = match[1];
 
@@ -736,11 +789,8 @@ less.Parser = function Parser(env) {
                             // Variable
                             if (param instanceof tree.Variable) {
                                 if ($(':')) {
-                                    if (value = $(this.expression)) {
-                                        params.push({ name: param.name, value: value });
-                                    } else {
-                                        throw new(Error)("Expected value");
-                                    }
+                                    value = expect(this.expression, 'expected expression');
+                                    params.push({ name: param.name, value: value });
                                 } else {
                                     params.push({ name: param.name });
                                 }
@@ -749,12 +799,18 @@ less.Parser = function Parser(env) {
                             }
                             if (! $(',')) { break }
                         }
-                        if (! $(')')) throw new(Error)("Expected )");
+                        expect(')');
+
+                        if ($(/^when/)) { // Guard
+                            cond = expect(this.conditions, 'expected condition');
+                        }
 
                         ruleset = $(this.block);
 
                         if (ruleset) {
-                            return new(tree.mixin.Definition)(name, params, ruleset);
+                            return new(tree.mixin.Definition)(name, params, ruleset, cond);
+                        } else {
+                            restore();
                         }
                     }
                 }
@@ -789,7 +845,7 @@ less.Parser = function Parser(env) {
 
                 if (! $(/^\(opacity=/i)) return;
                 if (value = $(/^\d+/) || $(this.entities.variable)) {
-                    if (! $(')')) throw new(Error)("missing closing ) for alpha()");
+                    expect(')');
                     return new(tree.Alpha)(value);
                 }
             },
@@ -807,12 +863,16 @@ less.Parser = function Parser(env) {
             // and an element name, such as a tag a class, or `*`.
             //
             element: function () {
-                var e, t, c;
+                var e, t, c, v;
 
                 c = $(this.combinator);
                 e = $(/^(?:\d+\.\d+|\d+)%/) || $(/^(?:[.#]?|:*)(?:[\w-]|\\(?:[a-fA-F0-9]{1,6} ?|[^a-fA-F0-9]))+/) ||
                     $('*') || $(this.attribute) || $(/^\([^)@]+\)/);
 
+                if (! e) {
+                    $('(') && (v = $(this.entities.variable)) && $(')') && (e = new(tree.Paren)(v));
+                }
+
                 if (e) { return new(tree.Element)(c, e, i) }
 
                 if (c.value && c.value.charAt(0) === '&') {
@@ -965,11 +1025,60 @@ less.Parser = function Parser(env) {
             // stored in `import`, which we pass to the Import constructor.
             //
             "import": function () {
-                var path;
+                var path, features, index = i;
                 if ($(/^@import\s+/) &&
-                    (path = $(this.entities.quoted) || $(this.entities.url)) &&
-                    $(';')) {
-                    return new(tree.Import)(path, imports);
+                    (path = $(this.entities.quoted) || $(this.entities.url))) {
+                    features = $(this.mediaFeatures);
+                    if ($(';')) {
+                        return new(tree.Import)(path, imports, features, index);
+                    }
+                }
+            },
+
+            mediaFeature: function () {
+                var nodes = [];
+
+                do {
+                    if (e = $(this.entities.keyword)) {
+                        nodes.push(e);
+                    } else if ($('(')) {
+                        p = $(this.property);
+                        e = $(this.entity);
+                        if ($(')')) {
+                            if (p && e) {
+                                nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, i, true)));
+                            } else if (e) {
+                                nodes.push(new(tree.Paren)(e));
+                            } else {
+                                return null;
+                            }
+                        } else { return null }
+                    }
+                } while (e);
+
+                if (nodes.length > 0) {
+                    return new(tree.Expression)(nodes);
+                }
+            },
+
+            mediaFeatures: function () {
+                var f, features = [];
+                while (f = $(this.mediaFeature)) {
+                    features.push(f);
+                    if (! $(',')) { break }
+                }
+                return features.length > 0 ? features : null;
+            },
+
+            media: function () {
+                var features;
+
+                if ($(/^@media/)) {
+                    features = $(this.mediaFeatures);
+
+                    if (rules = $(this.block)) {
+                        return new(tree.Directive)('@media', rules, features);
+                    }
                 }
             },
 
@@ -979,13 +1088,13 @@ less.Parser = function Parser(env) {
             //     @charset "utf-8";
             //
             directive: function () {
-                var name, value, rules, types;
+                var name, value, rules, types, e, nodes;
 
                 if (input.charAt(i) !== '@') return;
 
-                if (value = $(this['import'])) {
+                if (value = $(this['import']) || $(this.media)) {
                     return value;
-                } else if (name = $(/^@media|@page/) || $(/^@(?:-webkit-|-moz-|-o-)[a-z0-9-]+/) || $('keyframes')) {
+                } else if (name = $(/^@page|@keyframes/) || $(/^@(?:-webkit-|-moz-|-o-|-ms-)[a-z0-9-]+/)) {
                     types = ($(/^[^{]+/) || '').trim();
                     if (rules = $(this.block)) {
                         return new(tree.Directive)(name + " " + types, rules);
@@ -1052,7 +1161,7 @@ less.Parser = function Parser(env) {
             multiplication: function () {
                 var m, a, op, operation;
                 if (m = $(this.operand)) {
-                    while ((op = ($('/') || $('*'))) && (a = $(this.operand))) {
+                    while (!peek(/^\/\*/) && (op = ($('/') || $('*'))) && (a = $(this.operand))) {
                         operation = new(tree.Operation)(op, [operation || m, a]);
                     }
                     return operation || m;
@@ -1068,6 +1177,35 @@ less.Parser = function Parser(env) {
                     return operation || m;
                 }
             },
+            conditions: function () {
+                var a, b, index = i, condition;
+
+                if (a = $(this.condition)) {
+                    while ($(',') && (b = $(this.condition))) {
+                        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)) {
+                            c = new(tree.Condition)(op, a, b, index, negate);
+                        } else {
+                            error('expected expression');
+                        }
+                    } else {
+                        c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, negate);
+                    }
+                    expect(')');
+                    return $(/^and/) ? new(tree.Condition)('and', c, $(this.condition)) : c;
+                }
+            },
 
             //
             // An operand is anything that can be part of an operation,
@@ -1117,7 +1255,7 @@ if (less.mode === 'browser' || less.mode === 'rhino') {
     // Used by `@import` directives
     //
     less.Parser.importer = function (path, paths, callback, env) {
-        if (path.charAt(0) !== '/' && paths.length > 0) {
+        if (!/^([a-z]+:)?\//.test(path) && paths.length > 0) {
             path = paths[0] + path;
         }
         // We pass `true` as 3rd argument, to force the reload of the import.