less 1.7.4 → 1.7.5

package/lib/less/parser.js

@@ -1411,9 +1411,19 @@ less.Parser = function Parser(env) {
             combinator: function () {
                 var c = input.charAt(i);
 
+                if (c === '/') {
+                    save();
+                    var slashedCombinator = $re(/^\/[a-z]+\//i);
+                    if (slashedCombinator) {
+                        forget();
+                        return new(tree.Combinator)(slashedCombinator);
+                    }
+                    restore();
+                }
+
                 if (c === '>' || c === '+' || c === '~' || c === '|' || c === '^') {
                     i++;
-                    if (input.charAt(i) === '^') {
+                    if (c === '^' && input.charAt(i) === '^') {
                         c = '^^';
                         i++;
                     }
@@ -1568,6 +1578,7 @@ less.Parser = function Parser(env) {
                         value = this.detachedRuleset();
                     }
 
+                    this.comments();
                     if (!value) {
                         // prefer to try to parse first if its a variable or we are compressing
                         // but always fallback on the other one
@@ -1812,6 +1823,8 @@ less.Parser = function Parser(env) {
                         break;
                 }
 
+                this.comments();
+
                 if (hasIdentifier) {
                     value = this.entity();
                     if (!value) {
@@ -1829,6 +1842,8 @@ less.Parser = function Parser(env) {
                     }
                 }
 
+                this.comments();
+
                 if (hasBlock) {
                     rules = this.blockRuleset();
                 }
@@ -2043,9 +2058,20 @@ less.Parser = function Parser(env) {
                         return name.push(a[1]);
                     }
                 }
+                function cutOutBlockComments() {
+                    //match block comments
+                    var a = /^\s*\/\*(?:[^*]|\*+[^\/*])*\*+\//.exec(c);
+                    if (a) {
+                        length += a[0].length;
+                        c = c.slice(a[0].length);
+                        return true;
+                    }
+                    return false;
+                }
 
                 match(/^(\*?)/);
                 while (match(/^((?:[\w-]+)|(?:@\{[\w-]+\}))/)); // !
+                while (cutOutBlockComments());
                 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:

package/lib/less/tree/directive.js

@@ -24,7 +24,10 @@ tree.Directive.prototype = {
         }
     },
     isRulesetLike: function() {
-        return "@charset" !== this.name;
+        return !this.isCharset();
+    },
+    isCharset: function() {
+        return "@charset" === this.name;
     },
     genCSS: function (env, output) {
         var value = this.value, rules = this.rules;

package/lib/less/tree/element.js

@@ -77,30 +77,14 @@ tree.Combinator = function (value) {
 };
 tree.Combinator.prototype = {
     type: "Combinator",
-    _outputMap: {
-        ''  : '',
-        ' ' : ' ',
-        ':' : ' :',
-        '+' : ' + ',
-        '~' : ' ~ ',
-        '>' : ' > ',
-        '|' : '|',
-        '^' : ' ^ ',
-        '^^' : ' ^^ '
-    },
-    _outputMapCompressed: {
-        ''  : '',
-        ' ' : ' ',
-        ':' : ' :',
-        '+' : '+',
-        '~' : '~',
-        '>' : '>',
-        '|' : '|',
-        '^' : '^',
-        '^^' : '^^'
+    _noSpaceCombinators: {
+        '': true,
+        ' ': true,
+        '|': true
     },
     genCSS: function (env, output) {
-        output.add((env.compress ? this._outputMapCompressed : this._outputMap)[this.value]);
+        var spaceOrEmpty = (env.compress || this._noSpaceCombinators[this.value]) ? '' : ' ';
+        output.add(spaceOrEmpty + this.value + spaceOrEmpty);
     },
     toCSS: tree.toCSS
 };

package/lib/less/tree/rule.js

@@ -1,6 +1,6 @@
 (function (tree) {
 
-tree.Rule = function (name, value, important, merge, index, currentFileInfo, inline) {
+tree.Rule = function (name, value, important, merge, index, currentFileInfo, inline, variable) {
     this.name = name;
     this.value = (value instanceof tree.Value || value instanceof tree.Ruleset) ? value : new(tree.Value)([value]);
     this.important = important ? ' ' + important.trim() : '';
@@ -8,7 +8,8 @@ tree.Rule = function (name, value, important, merge, index, currentFileInfo, inl
     this.index = index;
     this.currentFileInfo = currentFileInfo;
     this.inline = inline || false;
-    this.variable = name.charAt && (name.charAt(0) === '@');
+    this.variable = (variable !== undefined) ? variable
+        : (name.charAt && (name.charAt(0) === '@'));
 };
 
 tree.Rule.prototype = {
@@ -30,13 +31,14 @@ tree.Rule.prototype = {
     },
     toCSS: tree.toCSS,
     eval: function (env) {
-        var strictMathBypass = false, name = this.name, evaldValue;
+        var strictMathBypass = false, name = this.name, variable = this.variable, evaldValue;
         if (typeof name !== "string") {
             // expand 'primitive' name directly to get
             // things faster (~10% for benchmark.less):
             name = (name.length === 1) 
                 && (name[0] instanceof tree.Keyword)
                     ? name[0].value : evalName(env, name);
+            variable = false; // never treat expanded interpolation as new variable name
         }
         if (name === "font" && !env.strictMath) {
             strictMathBypass = true;
@@ -54,7 +56,8 @@ tree.Rule.prototype = {
                               evaldValue,
                               this.important,
                               this.merge,
-                              this.index, this.currentFileInfo, this.inline);
+                              this.index, this.currentFileInfo, this.inline,
+                              variable);
         }
         catch(e) {
             if (typeof e.index !== 'number') {

package/lib/less/tree/rule.js.orig

@@ -0,0 +1,164 @@
+var Node = require("./node.js"),
+    Value = require("./value.js"),
+    Keyword = require("./keyword.js");
+
+<<<<<<< HEAD
+var Rule = function (name, value, important, merge, index, currentFileInfo, inline) {
+=======
+tree.Rule = function (name, value, important, merge, index, currentFileInfo, inline, variable) {
+>>>>>>> origin/master
+    this.name = name;
+    this.value = (value instanceof Node) ? value : new(Value)([value]); //value instanceof tree.Value || value instanceof tree.Ruleset ??
+    this.important = important ? ' ' + important.trim() : '';
+    this.merge = merge;
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+    this.inline = inline || false;
+    this.variable = (variable !== undefined) ? variable
+        : (name.charAt && (name.charAt(0) === '@'));
+};
+
+<<<<<<< HEAD
+=======
+tree.Rule.prototype = {
+    type: "Rule",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
+    genCSS: function (env, output) {
+        output.add(this.name + (env.compress ? ':' : ': '), this.currentFileInfo, this.index);
+        try {
+            this.value.genCSS(env, output);
+        }
+        catch(e) {
+            e.index = this.index;
+            e.filename = this.currentFileInfo.filename;
+            throw e;
+        }
+        output.add(this.important + ((this.inline || (env.lastRule && env.compress)) ? "" : ";"), this.currentFileInfo, this.index);
+    },
+    toCSS: tree.toCSS,
+    eval: function (env) {
+        var strictMathBypass = false, name = this.name, variable = this.variable, evaldValue;
+        if (typeof name !== "string") {
+            // expand 'primitive' name directly to get
+            // things faster (~10% for benchmark.less):
+            name = (name.length === 1) 
+                && (name[0] instanceof tree.Keyword)
+                    ? name[0].value : evalName(env, name);
+            variable = false; // never treat expanded interpolation as new variable name
+        }
+        if (name === "font" && !env.strictMath) {
+            strictMathBypass = true;
+            env.strictMath = true;
+        }
+        try {
+            evaldValue = this.value.eval(env);
+            
+            if (!this.variable && evaldValue.type === "DetachedRuleset") {
+                throw { message: "Rulesets cannot be evaluated on a property.",
+                        index: this.index, filename: this.currentFileInfo.filename };
+            }
+
+            return new(tree.Rule)(name,
+                              evaldValue,
+                              this.important,
+                              this.merge,
+                              this.index, this.currentFileInfo, this.inline,
+                              variable);
+        }
+        catch(e) {
+            if (typeof e.index !== 'number') {
+                e.index = this.index;
+                e.filename = this.currentFileInfo.filename;
+            }
+            throw e;
+        }
+        finally {
+            if (strictMathBypass) {
+                env.strictMath = false;
+            }
+        }
+    },
+    makeImportant: function () {
+        return new(tree.Rule)(this.name,
+                              this.value,
+                              "!important",
+                              this.merge,
+                              this.index, this.currentFileInfo, this.inline);
+    }
+};
+
+>>>>>>> origin/master
+function evalName(env, name) {
+    var value = "", i, n = name.length,
+        output = {add: function (s) {value += s;}};
+    for (i = 0; i < n; i++) {
+        name[i].eval(env).genCSS(env, output);
+    }
+    return value;
+}
+
+Rule.prototype = new Node();
+Rule.prototype.type = "Rule";
+Rule.prototype.genCSS = function (env, output) {
+    output.add(this.name + (env.compress ? ':' : ': '), this.currentFileInfo, this.index);
+    try {
+        this.value.genCSS(env, output);
+    }
+    catch(e) {
+        e.index = this.index;
+        e.filename = this.currentFileInfo.filename;
+        throw e;
+    }
+    output.add(this.important + ((this.inline || (env.lastRule && env.compress)) ? "" : ";"), this.currentFileInfo, this.index);
+};
+Rule.prototype.eval = function (env) {
+    var strictMathBypass = false, name = this.name, evaldValue;
+    if (typeof name !== "string") {
+        // expand 'primitive' name directly to get
+        // things faster (~10% for benchmark.less):
+        name = (name.length === 1)
+            && (name[0] instanceof Keyword)
+                ? name[0].value : evalName(env, name);
+    }
+    if (name === "font" && !env.strictMath) {
+        strictMathBypass = true;
+        env.strictMath = true;
+    }
+    try {
+        evaldValue = this.value.eval(env);
+
+        if (!this.variable && evaldValue.type === "DetachedRuleset") {
+            throw { message: "Rulesets cannot be evaluated on a property.",
+                    index: this.index, filename: this.currentFileInfo.filename };
+        }
+
+        return new(Rule)(name,
+                          evaldValue,
+                          this.important,
+                          this.merge,
+                          this.index, this.currentFileInfo, this.inline);
+    }
+    catch(e) {
+        if (typeof e.index !== 'number') {
+            e.index = this.index;
+            e.filename = this.currentFileInfo.filename;
+        }
+        throw e;
+    }
+    finally {
+        if (strictMathBypass) {
+            env.strictMath = false;
+        }
+    }
+};
+Rule.prototype.makeImportant = function () {
+    return new(Rule)(this.name,
+                          this.value,
+                          "!important",
+                          this.merge,
+                          this.index, this.currentFileInfo, this.inline);
+};
+
+module.exports = Rule;

package/lib/less/tree/ruleset.js

@@ -266,6 +266,7 @@ tree.Ruleset.prototype = {
     },
     genCSS: function (env, output) {
         var i, j,
+            charsetRuleNodes = [],
             ruleNodes = [],
             rulesetNodes = [],
             rulesetNodeCnt,
@@ -306,9 +307,15 @@ tree.Ruleset.prototype = {
             if (isRulesetLikeNode(rule, this.root)) {
                 rulesetNodes.push(rule);
             } else {
-                ruleNodes.push(rule);
+                //charsets should float on top of everything
+                if (rule.isCharset && rule.isCharset()) {
+                    charsetRuleNodes.push(rule);
+                } else {
+                    ruleNodes.push(rule);
+                }
             }
         }
+        ruleNodes = charsetRuleNodes.concat(ruleNodes);
 
         // If this is the root node, we don't render
         // a selector, or {}.

package/lib/less/tree/selector.js

@@ -73,7 +73,7 @@ tree.Selector.prototype = {
                 css += v.value.value;
             }
 
-            this._elements = css.match(/[,&#\.\w-]([\w-]|(\\.))*/g);
+            this._elements = css.match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
 
             if (this._elements) {
                 if (this._elements[0] === "&") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "less",
-  "version": "1.7.4",
+  "version": "1.7.5",
   "description": "Leaner CSS",
   "homepage": "http://lesscss.org",
   "author": {
@@ -31,7 +31,7 @@
     "test": "./test"
   },
   "jam": {
-    "main": "./dist/less-1.6.3.js"
+    "main": "./dist/less-1.7.5.js"
   },
   "engines": {
     "node": ">=0.8.0"
@@ -40,11 +40,11 @@
     "test": "grunt test"
   },
   "optionalDependencies": {
-    "graceful-fs": "~2.0.3",
+    "graceful-fs": "~3.0.2",
     "mime": "~1.2.11",
-    "request": "~2.34.0",
-    "mkdirp": "~0.3.5",
-    "clean-css": "2.1.x",
+    "request": "~2.40.0",
+    "mkdirp": "~0.5.0",
+    "clean-css": "2.2.x",
     "source-map": "0.1.x"
   },
   "devDependencies": {