less 2.3.3 → 2.4.0

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

@@ -11,11 +11,16 @@ tree.Directive = function (name, value) {
     }
 };
 tree.Directive.prototype = {
-    toCSS: function (ctx, env) {
+    type: "Directive",
+    accept: function (visitor) {
+        this.ruleset = visitor.visit(this.ruleset);
+        this.value = visitor.visit(this.value);
+    },
+    toCSS: function (env) {
         if (this.ruleset) {
             this.ruleset.root = true;
             return this.name + (env.compress ? '{' : ' {\n  ') +
-                   this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
+                   this.ruleset.toCSS(env).trim().replace(/\n/g, '\n  ') +
                                (env.compress ? '}': '\n}\n');
         } else {
             return this.name + ' ' + this.value.toCSS() + ';\n';

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

@@ -13,18 +13,51 @@ tree.Element = function (combinator, value, index) {
     }
     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 = {
+    type: "Element",
+    accept: function (visitor) {
+        this.combinator = visitor.visit(this.combinator);
+        this.value = visitor.visit(this.value);
+    },
+    eval: function (env) {
+        return new(tree.Element)(this.combinator,
+                                 this.value.eval ? this.value.eval(env) : this.value,
+                                 this.index);
+    },
+    toCSS: function (env) {
+        var value = (this.value.toCSS ? this.value.toCSS(env) : this.value);
+        if (value == '' && this.combinator.value.charAt(0) == '&') {
+            return '';
+        } else {
+            return this.combinator.toCSS(env || {}) + value;
+        }
+    }
 };
-tree.Element.prototype.toCSS = function (env) {
-	var value = (this.value.toCSS ? this.value.toCSS(env) : this.value);
-	if (value == '' && this.combinator.value.charAt(0) == '&') {
-		return '';
-	} else {
-		return this.combinator.toCSS(env || {}) + value;
-	}
+
+tree.Attribute = function (key, op, value) {
+    this.key = key;
+    this.op = op;
+    this.value = value;
+};
+tree.Attribute.prototype = {
+    type: "Attribute",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
+    eval: function (env) {
+        return new(tree.Attribute)(this.key.eval ? this.key.eval(env) : this.key,
+            this.op, (this.value && this.value.eval) ? this.value.eval(env) : this.value);
+    },
+    toCSS: function (env) {
+        var value = this.key.toCSS ? this.key.toCSS(env) : this.key;
+
+        if (this.op) {
+            value += this.op;
+            value += (this.value.toCSS ? this.value.toCSS(env) : this.value);
+        }
+
+        return '[' + value + ']';
+    }
 };
 
 tree.Combinator = function (value) {
@@ -34,16 +67,19 @@ tree.Combinator = function (value) {
         this.value = value ? value.trim() : "";
     }
 };
-tree.Combinator.prototype.toCSS = function (env) {
-    return {
-        ''  : '',
-        ' ' : ' ',
-        ':' : ' :',
-        '+' : env.compress ? '+' : ' + ',
-        '~' : env.compress ? '~' : ' ~ ',
-        '>' : env.compress ? '>' : ' > ',
-        '|' : env.compress ? '|' : ' | '
-    }[this.value];
+tree.Combinator.prototype = {
+    type: "Combinator",
+    toCSS: function (env) {
+        return {
+            ''  : '',
+            ' ' : ' ',
+            ':' : ' :',
+            '+' : env.compress ? '+' : ' + ',
+            '~' : env.compress ? '~' : ' ~ ',
+            '>' : env.compress ? '>' : ' > ',
+            '|' : env.compress ? '|' : ' | '
+        }[this.value];
+    }
 };
 
 })(require('../tree'));

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

@@ -1,22 +1,47 @@
 (function (tree) {
 
-tree.Expression = function (value) { this.value = value };
+tree.Expression = function (value) { this.value = value; };
 tree.Expression.prototype = {
+    type: "Expression",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
     eval: function (env) {
+        var returnValue,
+            inParenthesis = this.parens && !this.parensInOp,
+            doubleParen = false;
+        if (inParenthesis) {
+            env.inParenthesis();
+        }
         if (this.value.length > 1) {
-            return new(tree.Expression)(this.value.map(function (e) {
+            returnValue = new(tree.Expression)(this.value.map(function (e) {
                 return e.eval(env);
             }));
         } else if (this.value.length === 1) {
-            return this.value[0].eval(env);
+            if (this.value[0].parens && !this.value[0].parensInOp) {
+                doubleParen = true;
+            }
+            returnValue = this.value[0].eval(env);
         } else {
-            return this;
+            returnValue = this;
+        }
+        if (inParenthesis) {
+            env.outOfParenthesis();
         }
+        if (this.parens && this.parensInOp && !(env.isMathOn()) && !doubleParen) {
+            returnValue = new(tree.Paren)(returnValue);
+        }
+        return returnValue;
     },
     toCSS: function (env) {
         return this.value.map(function (e) {
             return e.toCSS ? e.toCSS(env) : '';
         }).join(' ');
+    },
+    throwAwayComments: function () {
+        this.value = this.value.filter(function(v) {
+            return !(v instanceof tree.Comment);
+        });
     }
 };
 

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

@@ -0,0 +1,43 @@
+(function (tree) {
+
+tree.Extend = function Extend(selector, option, index) {
+    this.selector = selector;
+    this.option = option;
+    this.index = index;
+
+    switch(option) {
+        case "all":
+            this.allowBefore = true;
+            this.allowAfter = true;
+        break;
+        default:
+            this.allowBefore = false;
+            this.allowAfter = false;
+        break;
+    }
+};
+
+tree.Extend.prototype = {
+    type: "Extend",
+    accept: function (visitor) {
+        this.selector = visitor.visit(this.selector);
+    },
+    eval: function (env) {
+        return new(tree.Extend)(this.selector.eval(env), this.option, this.index);
+    },
+    clone: function (env) {
+        return new(tree.Extend)(this.selector, this.option, this.index);
+    },
+    findSelfSelectors: function (selectors) {
+        var selfElements = [],
+            i;
+
+        for(i = 0; i < selectors.length; i++) {
+            selfElements = selfElements.concat(selectors[i].elements);
+        }
+
+        this.selfSelectors = [{ elements: selfElements }];
+    }
+};
+
+})(require('../tree'));

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

@@ -11,31 +11,22 @@
 // `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, features, once, index, rootpath) {
+tree.Import = function (path, features, options, index, currentFileInfo) {
     var that = this;
 
-    this.once = once;
+    this.options = options;
     this.index = index;
-    this._path = path;
-    this.features = features && new(tree.Value)(features);
-    this.rootpath = rootpath;
-		
-    // The '.less' extension is optional
-    if (path instanceof tree.Quoted) {
-        this.path = /(\.[a-z]*$)|([\?;].*)$/.test(path.value) ? path.value : path.value + '.less';
-    } else {
-        this.path = path.value.value || path.value;
-    }
+    this.path = path;
+    this.features = features;
+    this.currentFileInfo = currentFileInfo;
 
-    this.css = /css([\?;].*)?$/.test(this.path);
-
-    // Only pre-compile .less files
-    if (! this.css) {
-        imports.push(this.path, function (e, root, imported) {
-            if (e) { e.index = index }
-            if (imported && that.once) that.skip = imported;
-            that.root = root || new(tree.Ruleset)([], []);
-        });
+    if (this.options.less !== undefined) {
+        this.css = !this.options.less;
+    } else {
+        var pathValue = this.getPath();
+        if (pathValue && /css([\?;].*)?$/.test(pathValue)) {
+            this.css = true;
+        }
     }
 };
 
@@ -49,26 +40,56 @@ tree.Import = function (path, imports, features, once, index, rootpath) {
 // ruleset.
 //
 tree.Import.prototype = {
+    type: "Import",
+    accept: function (visitor) {
+        this.features = visitor.visit(this.features);
+        this.path = visitor.visit(this.path);
+        this.root = visitor.visit(this.root);
+    },
     toCSS: function (env) {
         var features = this.features ? ' ' + this.features.toCSS(env) : '';
 
         if (this.css) {
-            // Add the base path if the import is relative
-            if (typeof this._path.value === "string" && !/^(?:[a-z-]+:|\/)/.test(this._path.value)) {
-                this._path.value = this.rootpath + this._path.value;
-            }
-            return "@import " + this._path.toCSS() + features + ';\n';
+            return "@import " + this.path.toCSS() + features + ';\n';
         } else {
             return "";
         }
     },
+    getPath: function () {
+        if (this.path instanceof tree.Quoted) {
+            var path = this.path.value;
+            return (this.css !== undefined || /(\.[a-z]*$)|([\?;].*)$/.test(path)) ? path : path + '.less';
+        } else if (this.path instanceof tree.URL) {
+            return this.path.value.value;
+        }
+        return null;
+    },
+    evalForImport: function (env) {
+        return new(tree.Import)(this.path.eval(env), this.features, this.options, this.index, this.currentFileInfo);
+    },
+    evalPath: function (env) {
+        var path = this.path.eval(env);
+        var rootpath = this.currentFileInfo && this.currentFileInfo.rootpath;
+        if (rootpath && !(path instanceof tree.URL)) {
+            var pathValue = path.value;
+            // Add the base path if the import is relative
+            if (pathValue && env.isPathRelative(pathValue)) {
+                path.value =  rootpath + pathValue;
+            }
+        }
+        return path;
+    },
     eval: function (env) {
         var ruleset, features = this.features && this.features.eval(env);
 
-        if (this.skip) return [];
+        if (this.skip) { return []; }
 
         if (this.css) {
-            return this;
+            var newImport = new(tree.Import)(this.evalPath(env), features, this.options, this.index);
+            if (!newImport.css && this.error) {
+                throw this.error;
+            }
+            return newImport;
         } else {
             ruleset = new(tree.Ruleset)([], this.root.rules.slice(0));
 

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

@@ -6,6 +6,7 @@ tree.JavaScript = function (string, index, escaped) {
     this.index = index;
 };
 tree.JavaScript.prototype = {
+    type: "JavaScript",
     eval: function (env) {
         var result,
             that = this,

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

@@ -2,8 +2,9 @@
 
 tree.Keyword = function (value) { this.value = value };
 tree.Keyword.prototype = {
-    eval: function () { return this },
-    toCSS: function () { return this.value },
+    type: "Keyword",
+    eval: function () { return this; },
+    toCSS: function () { return this.value; },
     compare: function (other) {
         if (other instanceof tree.Keyword) {
             return other.value === this.value ? 0 : 1;

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

@@ -8,12 +8,16 @@ tree.Media = function (value, features) {
     this.ruleset.allowImports = true;
 };
 tree.Media.prototype = {
-    toCSS: function (ctx, env) {
+    type: "Media",
+    accept: function (visitor) {
+        this.features = visitor.visit(this.features);
+        this.ruleset = visitor.visit(this.ruleset);
+    },
+    toCSS: function (env) {
         var features = this.features.toCSS(env);
 
-        this.ruleset.root = (ctx.length === 0 || ctx[0].multiMedia);
         return '@media ' + features + (env.compress ? '{' : ' {\n  ') +
-               this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
+               this.ruleset.toCSS(env).trim().replace(/\n/g, '\n  ') +
                            (env.compress ? '}': '\n}\n');
     },
     eval: function (env) {
@@ -27,7 +31,19 @@ tree.Media.prototype = {
             this.ruleset.debugInfo = this.debugInfo;
             media.debugInfo = this.debugInfo;
         }
-        media.features = this.features.eval(env);
+        var strictMathBypass = false;
+        if (!env.strictMath) {
+            strictMathBypass = true;
+            env.strictMath = true;
+        }
+        try {
+            media.features = this.features.eval(env);
+        }
+        finally {
+            if (strictMathBypass) {
+                env.strictMath = false;
+            }
+        }
         
         env.mediaPath.push(media);
         env.mediaBlocks.push(media);

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

@@ -1,14 +1,19 @@
 (function (tree) {
 
 tree.mixin = {};
-tree.mixin.Call = function (elements, args, index, filename, important) {
+tree.mixin.Call = function (elements, args, index, currentFileInfo, important) {
     this.selector = new(tree.Selector)(elements);
     this.arguments = args;
     this.index = index;
-    this.filename = filename;
+    this.currentFileInfo = currentFileInfo;
     this.important = important;
 };
 tree.mixin.Call.prototype = {
+    type: "MixinCall",
+    accept: function (visitor) {
+        this.selector = visitor.visit(this.selector);
+        this.arguments = visitor.visit(this.arguments);
+    },
     eval: function (env) {
         var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound;
 
@@ -37,7 +42,7 @@ tree.mixin.Call.prototype = {
                                 Array.prototype.push.apply(
                                       rules, mixin.eval(env, args, this.important).rules);
                             } catch (e) {
-                                throw { message: e.message, index: this.index, filename: this.filename, stack: e.stack };
+                                throw { message: e.message, index: this.index, filename: this.currentFileInfo.filename, stack: e.stack };
                             }
                         }
                         match = true;
@@ -64,11 +69,11 @@ tree.mixin.Call.prototype = {
                                   }
                                   return argValue;
                               }).join(', ') : "") + ")`",
-                    index:   this.index, filename: this.filename };
+                    index:   this.index, filename: this.currentFileInfo.filename };
         } else {
             throw { type: 'Name',
                 message: this.selector.toCSS().trim() + " is undefined",
-                index: this.index, filename: this.filename };
+                index: this.index, filename: this.currentFileInfo.filename };
         }
     }
 };
@@ -90,14 +95,25 @@ tree.mixin.Definition = function (name, params, rules, condition, variadic) {
     this.frames = [];
 };
 tree.mixin.Definition.prototype = {
-    toCSS:     function ()     { return "" },
-    variable:  function (name) { return this.parent.variable.call(this, name) },
-    variables: function ()     { return this.parent.variables.call(this) },
-    find:      function ()     { return this.parent.find.apply(this, arguments) },
-    rulesets:  function ()     { return this.parent.rulesets.apply(this) },
+    type: "MixinDefinition",
+    accept: function (visitor) {
+        this.params = visitor.visit(this.params);
+        this.rules = visitor.visit(this.rules);
+        this.condition = visitor.visit(this.condition);
+    },
+    toCSS:     function ()     { return ""; },
+    variable:  function (name) { return this.parent.variable.call(this, name); },
+    variables: function ()     { return this.parent.variables.call(this); },
+    find:      function ()     { return this.parent.find.apply(this, arguments); },
+    rulesets:  function ()     { return this.parent.rulesets.apply(this); },
 
     evalParams: function (env, mixinEnv, args, evaldArguments) {
-        var frame = new(tree.Ruleset)(null, []), varargs, arg, params = this.params.slice(0), i, j, val, name, isNamedFound, argIndex;
+        var frame = new(tree.Ruleset)(null, []),
+            varargs, arg,
+            params = this.params.slice(0),
+            i, j, val, name, isNamedFound, argIndex;
+
+        mixinEnv = new tree.evalEnv(mixinEnv, [frame].concat(mixinEnv.frames));
         
         if (args) {
             args = args.slice(0);
@@ -144,6 +160,7 @@ tree.mixin.Definition.prototype = {
                         val = val.eval(env);
                     } else if (params[i].value) {
                         val = params[i].value.eval(mixinEnv);
+                        frame.resetCache();
                     } else {
                         throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
                             ' (' + args.length + ' for ' + this.arity + ')' };
@@ -167,7 +184,7 @@ tree.mixin.Definition.prototype = {
     eval: function (env, args, important) {
         var _arguments = [],
             mixinFrames = this.frames.concat(env.frames),
-            frame = this.evalParams(env, {frames: mixinFrames}, args, _arguments), 
+            frame = this.evalParams(env, new(tree.evalEnv)(env, mixinFrames), args, _arguments),
             context, rules, start, ruleset;
 
         frame.rules.unshift(new(tree.Rule)('@arguments', new(tree.Expression)(_arguments).eval(env)));
@@ -175,16 +192,19 @@ tree.mixin.Definition.prototype = {
         rules = important ?
             this.parent.makeImportant.apply(this).rules : this.rules.slice(0);
 
-        ruleset = new(tree.Ruleset)(null, rules).eval({
-            frames: [this, frame].concat(mixinFrames)
-        });
+        ruleset = new(tree.Ruleset)(null, rules).eval(new(tree.evalEnv)(env,
+                                                    [this, frame].concat(mixinFrames)));
         ruleset.originalRuleset = this;
         return ruleset;
     },
     matchCondition: function (args, env) {
-        if (this.condition && !this.condition.eval({
-            frames: [this.evalParams(env, {frames: this.frames.concat(env.frames)}, args, [])].concat(env.frames)
-        }))                                                           { return false }
+
+        if (this.condition && !this.condition.eval(
+            new(tree.evalEnv)(env,
+                [this.evalParams(env, new(tree.evalEnv)(env, this.frames.concat(env.frames)), args, [])]
+                    .concat(env.frames)))) {
+            return false;
+        }
         return true;
     },
     matchArgs: function (args, env) {