less 2.0.8 → 2.0.9

data/lib/less/js/lib/less/rhino.js

@@ -3,7 +3,9 @@ var name;
 function loadStyleSheet(sheet, callback, reload, remaining) {
     var sheetName = name.slice(0, name.lastIndexOf('/') + 1) + sheet.href;
     var input = readFile(sheetName);
-    var parser = new less.Parser();
+    var parser = new less.Parser({
+        paths: [sheet.href.replace(/[\w\.-]+$/, '')]
+    });
     parser.parse(input, function (e, root) {
         if (e) {
             print("Error: " + e);

data/lib/less/js/lib/less/tree.js

@@ -1,13 +1,17 @@
-require('./tree').find = function (obj, fun) {
+(function (tree) {
+
+tree.find = function (obj, fun) {
     for (var i = 0, r; i < obj.length; i++) {
         if (r = fun.call(obj, obj[i])) { return r }
     }
     return null;
 };
-require('./tree').jsify = function (obj) {
+tree.jsify = function (obj) {
     if (Array.isArray(obj.value) && (obj.value.length > 1)) {
         return '[' + obj.value.map(function (v) { return v.toCSS(false) }).join(', ') + ']';
     } else {
         return obj.toCSS(false);
     }
 };
+
+})(require('./tree'));

data/lib/less/js/lib/less/tree/call.js

@@ -3,10 +3,11 @@
 //
 // A function call node.
 //
-tree.Call = function (name, args, index) {
+tree.Call = function (name, args, index, filename) {
     this.name = name;
     this.args = args;
     this.index = index;
+    this.filename = filename;
 };
 tree.Call.prototype = {
     //
@@ -28,8 +29,10 @@ tree.Call.prototype = {
             try {
                 return tree.functions[this.name].apply(tree.functions, args);
             } catch (e) {
-                throw { message: "error evaluating function `" + this.name + "`",
-                        index: this.index };
+                throw { type: e.type || "Runtime",
+                        message: "error evaluating function `" + this.name + "`" +
+                                 (e.message ? ': ' + e.message : ''),
+                        index: this.index, filename: this.filename };
             }
         } else { // 2.
             return new(tree.Anonymous)(this.name +

data/lib/less/js/lib/less/tree/condition.js

@@ -0,0 +1,42 @@
+(function (tree) {
+
+tree.Condition = function (op, l, r, i, negate) {
+    this.op = op.trim();
+    this.lvalue = l;
+    this.rvalue = r;
+    this.index = i;
+    this.negate = negate;
+};
+tree.Condition.prototype.eval = function (env) {
+    var a = this.lvalue.eval(env),
+        b = this.rvalue.eval(env);
+
+    var i = this.index, result;
+
+    var result = (function (op) {
+        switch (op) {
+            case 'and':
+                return a && b;
+            case 'or':
+                return a || b;
+            default:
+                if (a.compare) {
+                    result = a.compare(b);
+                } else if (b.compare) {
+                    result = b.compare(a);
+                } else {
+                    throw { type: "Type",
+                            message: "Unable to perform comparison",
+                            index: i };
+                }
+                switch (result) {
+                    case -1: return op === '<' || op === '=<';
+                    case  0: return op === '=' || op === '>=' || op === '=<';
+                    case  1: return op === '>' || op === '>=';
+                }
+        }
+    })(this.op);
+    return this.negate ? !result : result;
+};
+
+})(require('../tree'));

data/lib/less/js/lib/less/tree/dimension.js

@@ -28,6 +28,21 @@ tree.Dimension.prototype = {
         return new(tree.Dimension)
                   (tree.operate(op, this.value, other.value),
                   this.unit || other.unit);
+    },
+
+    // TODO: Perform unit conversion before comparing
+    compare: function (other) {
+        if (other instanceof tree.Dimension) {
+            if (other.value > this.value) {
+                return -1;
+            } else if (other.value < this.value) {
+                return 1;
+            } else {
+                return 0;
+            }
+        } else {
+            return -1;
+        }
     }
 };
 

data/lib/less/js/lib/less/tree/directive.js

@@ -1,18 +1,23 @@
 (function (tree) {
 
-tree.Directive = function (name, value) {
+tree.Directive = function (name, value, features) {
     this.name = name;
+    this.features = features && new(tree.Value)(features);
+
     if (Array.isArray(value)) {
         this.ruleset = new(tree.Ruleset)([], value);
+        this.ruleset.allowImports = true;
     } else {
         this.value = value;
     }
 };
 tree.Directive.prototype = {
     toCSS: function (ctx, env) {
+        var features = this.features ? ' ' + this.features.toCSS(env) : '';
+
         if (this.ruleset) {
             this.ruleset.root = true;
-            return this.name + (env.compress ? '{' : ' {\n  ') +
+            return this.name + features + (env.compress ? '{' : ' {\n  ') +
                    this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
                                (env.compress ? '}': '\n}\n');
         } else {
@@ -20,6 +25,7 @@ tree.Directive.prototype = {
         }
     },
     eval: function (env) {
+        this.features = this.features && this.features.eval(env);
         env.frames.unshift(this);
         this.ruleset = this.ruleset && this.ruleset.eval(env);
         env.frames.shift();

data/lib/less/js/lib/less/tree/element.js

@@ -3,11 +3,23 @@
 tree.Element = function (combinator, value, index) {
     this.combinator = combinator instanceof tree.Combinator ?
                       combinator : new(tree.Combinator)(combinator);
-    this.value = value ? value.trim() : "";
+
+    if (typeof(value) === 'string') {
+        this.value = value.trim();
+    } else if (value) {
+        this.value = value;
+    } else {
+        this.value = "";
+    }
     this.index = index;
 };
+tree.Element.prototype.eval = function (env) {
+    return new(tree.Element)(this.combinator,
+                             this.value.eval ? this.value.eval(env) : this.value,
+                             this.index);
+};
 tree.Element.prototype.toCSS = function (env) {
-    return this.combinator.toCSS(env || {}) + this.value;
+    return this.combinator.toCSS(env || {}) + (this.value.toCSS ? this.value.toCSS(env) : this.value);
 };
 
 tree.Combinator = function (value) {

data/lib/less/js/lib/less/tree/expression.js

@@ -15,7 +15,7 @@ tree.Expression.prototype = {
     },
     toCSS: function (env) {
         return this.value.map(function (e) {
-            return e.toCSS(env);
+            return e.toCSS ? e.toCSS(env) : '';
         }).join(' ');
     }
 };

data/lib/less/js/lib/less/tree/import.js

@@ -11,10 +11,12 @@
 // `import,push`, we also pass it a callback, which it'll call once
 // the file has been fetched, and parsed.
 //
-tree.Import = function (path, imports) {
+tree.Import = function (path, imports, features, index) {
     var that = this;
 
+    this.index = index;
     this._path = path;
+    this.features = features && new(tree.Value)(features);
 
     // The '.less' extension is optional
     if (path instanceof tree.Quoted) {
@@ -27,11 +29,9 @@ tree.Import = function (path, imports) {
 
     // Only pre-compile .less files
     if (! this.css) {
-        imports.push(this.path, function (root) {
-            if (! root) {
-                throw new(Error)("Error parsing " + that.path);
-            }
-            that.root = root;
+        imports.push(this.path, function (e, root) {
+            if (e) { e.index = index }
+            that.root = root || new(tree.Ruleset)([], []);
         });
     }
 };
@@ -46,20 +46,22 @@ tree.Import = function (path, imports) {
 // ruleset.
 //
 tree.Import.prototype = {
-    toCSS: function () {
+    toCSS: function (env) {
+        var features = this.features ? ' ' + this.features.toCSS(env) : '';
+
         if (this.css) {
-            return "@import " + this._path.toCSS() + ';\n';
+            return "@import " + this._path.toCSS() + features + ';\n';
         } else {
             return "";
         }
     },
     eval: function (env) {
-        var ruleset;
+        var ruleset, features = this.features && this.features.eval(env);
 
         if (this.css) {
             return this;
         } else {
-            ruleset = new(tree.Ruleset)(null, this.root.rules.slice(0));
+            ruleset = new(tree.Ruleset)([], this.root.rules.slice(0));
 
             for (var i = 0; i < ruleset.rules.length; i++) {
                 if (ruleset.rules[i] instanceof tree.Import) {
@@ -69,7 +71,7 @@ tree.Import.prototype = {
                                 [i, 1].concat(ruleset.rules[i].eval(env)));
                 }
             }
-            return ruleset.rules;
+            return this.features ? new(tree.Directive)('@media', ruleset.rules, this.features.value) : ruleset.rules;
         }
     }
 };

data/lib/less/js/lib/less/tree/keyword.js

@@ -3,7 +3,17 @@
 tree.Keyword = function (value) { this.value = value };
 tree.Keyword.prototype = {
     eval: function () { return this },
-    toCSS: function () { return this.value }
+    toCSS: function () { return this.value },
+    compare: function (other) {
+        if (other instanceof tree.Keyword) {
+            return other.value === this.value ? 0 : 1;
+        } else {
+            return -1;
+        }
+    }
 };
 
+tree.True = new(tree.Keyword)('true');
+tree.False = new(tree.Keyword)('false');
+
 })(require('../tree'));

data/lib/less/js/lib/less/tree/mixin.js

@@ -1,10 +1,12 @@
 (function (tree) {
 
 tree.mixin = {};
-tree.mixin.Call = function (elements, args, index) {
+tree.mixin.Call = function (elements, args, index, filename, important) {
     this.selector = new(tree.Selector)(elements);
     this.arguments = args;
     this.index = index;
+    this.filename = filename;
+    this.important = important;
 };
 tree.mixin.Call.prototype = {
     eval: function (env) {
@@ -17,34 +19,37 @@ tree.mixin.Call.prototype = {
                     if (mixins[m].match(args, env)) {
                         try {
                             Array.prototype.push.apply(
-                                  rules, mixins[m].eval(env, this.arguments).rules);
+                                  rules, mixins[m].eval(env, this.arguments, this.important).rules);
                             match = true;
                         } catch (e) {
-                            throw { message: e.message, index: e.index, stack: e.stack, call: this.index };
+                            throw { message: e.message, index: e.index, filename: this.filename, stack: e.stack, call: this.index };
                         }
                     }
                 }
                 if (match) {
                     return rules;
                 } else {
-                    throw { message: 'No matching definition was found for `' +
+                    throw { type:    'Runtime',
+                            message: 'No matching definition was found for `' +
                                       this.selector.toCSS().trim() + '('      +
                                       this.arguments.map(function (a) {
                                           return a.toCSS();
                                       }).join(', ') + ")`",
-                            index:   this.index };
+                            index:   this.index, filename: this.filename };
                 }
             }
         }
-        throw { message: this.selector.toCSS().trim() + " is undefined",
-                index: this.index };
+        throw { type: 'Name',
+                message: this.selector.toCSS().trim() + " is undefined",
+                index: this.index, filename: this.filename };
     }
 };
 
-tree.mixin.Definition = function (name, params, rules) {
+tree.mixin.Definition = function (name, params, rules, condition) {
     this.name = name;
     this.selectors = [new(tree.Selector)([new(tree.Element)(null, name)])];
     this.params = params;
+    this.condition = condition;
     this.arity = params.length;
     this.rules = rules;
     this._lookups = {};
@@ -62,33 +67,46 @@ tree.mixin.Definition.prototype = {
     find:      function ()     { return this.parent.find.apply(this, arguments) },
     rulesets:  function ()     { return this.parent.rulesets.apply(this) },
 
-    eval: function (env, args) {
-        var frame = new(tree.Ruleset)(null, []), context, _arguments = [];
+    evalParams: function (env, args) {
+        var frame = new(tree.Ruleset)(null, []);
 
         for (var i = 0, val; i < this.params.length; i++) {
             if (this.params[i].name) {
                 if (val = (args && args[i]) || this.params[i].value) {
                     frame.rules.unshift(new(tree.Rule)(this.params[i].name, val.eval(env)));
                 } else {
-                    throw { message: "wrong number of arguments for " + this.name +
+                    throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
                             ' (' + args.length + ' for ' + this.arity + ')' };
                 }
             }
         }
+        return frame;
+    },
+    eval: function (env, args, important) {
+        var frame = this.evalParams(env, args), context, _arguments = [], rules;
+
         for (var i = 0; i < Math.max(this.params.length, args && args.length); i++) {
             _arguments.push(args[i] || this.params[i].value);
         }
         frame.rules.unshift(new(tree.Rule)('@arguments', new(tree.Expression)(_arguments).eval(env)));
 
-        return new(tree.Ruleset)(null, this.rules.slice(0)).eval({
+        rules = important ?
+            this.rules.map(function (r) {
+                return new(tree.Rule)(r.name, r.value, '!important', r.index);
+            }) : this.rules.slice(0);
+
+        return new(tree.Ruleset)(null, rules).eval({
             frames: [this, frame].concat(this.frames, env.frames)
         });
     },
     match: function (args, env) {
-        var argsLength = (args && args.length) || 0, len;
+        var argsLength = (args && args.length) || 0, len, frame;
 
         if (argsLength < this.required)                               { return false }
         if ((this.required > 0) && (argsLength > this.params.length)) { return false }
+        if (this.condition && !this.condition.eval({
+            frames: [this.evalParams(env, args)].concat(env.frames)
+        }))                                                           { return false }
 
         len = Math.min(argsLength, this.arity);
 

data/lib/less/js/lib/less/tree/paren.js

@@ -0,0 +1,16 @@
+
+(function (tree) {
+
+tree.Paren = function (node) {
+    this.value = node;
+};
+tree.Paren.prototype = {
+    toCSS: function (env) {
+        return '(' + this.value.toCSS(env) + ')';
+    },
+    eval: function (env) {
+        return new(tree.Paren)(this.value.eval(env));
+    }
+};
+
+})(require('../tree'));

data/lib/less/js/lib/less/tree/quoted.js

@@ -20,7 +20,7 @@ tree.Quoted.prototype = {
             return new(tree.JavaScript)(exp, that.index, true).eval(env).value;
         }).replace(/@\{([\w-]+)\}/g, function (_, name) {
             var v = new(tree.Variable)('@' + name, that.index).eval(env);
-            return v.value || v.toCSS();
+            return ('value' in v) ? v.value : v.toCSS();
         });
         return new(tree.Quoted)(this.quote + value + this.quote, value, this.escaped, this.index);
     }

data/lib/less/js/lib/less/tree/rule.js

@@ -1,10 +1,11 @@
 (function (tree) {
 
-tree.Rule = function (name, value, important, index) {
+tree.Rule = function (name, value, important, index, inline) {
     this.name = name;
     this.value = (value instanceof tree.Value) ? value : new(tree.Value)([value]);
     this.important = important ? ' ' + important.trim() : '';
     this.index = index;
+    this.inline = inline || false;
 
     if (name.charAt(0) === '@') {
         this.variable = true;
@@ -15,12 +16,15 @@ tree.Rule.prototype.toCSS = function (env) {
     else {
         return this.name + (env.compress ? ':' : ': ') +
                this.value.toCSS(env) +
-               this.important + ";";
+               this.important + (this.inline ? "" : ";");
     }
 };
 
 tree.Rule.prototype.eval = function (context) {
-    return new(tree.Rule)(this.name, this.value.eval(context), this.important, this.index);
+    return new(tree.Rule)(this.name,
+                          this.value.eval(context),
+                          this.important,
+                          this.index, this.inline);
 };
 
 tree.Shorthand = function (a, b) {