less 1.7.0 → 1.7.5

package/lib/less/parser.js

@@ -225,7 +225,7 @@ less.Parser = function Parser(env) {
         return oldi !== i || oldj !== j;
     }
 
-    function expect(arg, msg) {
+    function expect(arg, msg, index) {
         // some older browsers return typeof 'function' for RegExp
         var result = (Object.prototype.toString.call(arg) === '[object Function]') ? arg.call(parsers) : $(arg);
         if (result) {
@@ -405,8 +405,8 @@ less.Parser = function Parser(env) {
 
                     switch (cc) {
                         case 40:                        // (
-                            parenLevel++; 
-                            lastOpeningParen = parserCurrentIndex; 
+                            parenLevel++;
+                            lastOpeningParen = parserCurrentIndex;
                             continue;
                         case 41:                        // )
                             if (--parenLevel < 0) {
@@ -417,8 +417,8 @@ less.Parser = function Parser(env) {
                             if (!parenLevel) { emitChunk(); }
                             continue;
                         case 123:                       // {
-                            level++; 
-                            lastOpening = parserCurrentIndex; 
+                            level++;
+                            lastOpening = parserCurrentIndex;
                             continue;
                         case 125:                       // }
                             if (--level < 0) {
@@ -517,7 +517,7 @@ less.Parser = function Parser(env) {
                     var evaldRoot,
                         css,
                         evalEnv = new tree.evalEnv(options);
-                        
+
                     //
                     // Allows setting variables with a hash, so:
                     //
@@ -685,7 +685,7 @@ less.Parser = function Parser(env) {
         //
         //   Ruleset ->  Rule -> Value -> Expression -> Entity
         //
-        // Here's some LESS code:
+        // Here's some Less code:
         //
         //    .class {
         //      color: #fff;
@@ -960,6 +960,11 @@ less.Parser = function Parser(env) {
                     var rgb;
 
                     if (input.charAt(i) === '#' && (rgb = $re(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/))) {
+                        var colorCandidateString = rgb.input.match(/^#([\w]+).*/); // strip colons, brackets, whitespaces and other characters that should not definitely be part of color string
+                        colorCandidateString = colorCandidateString[1];
+                        if (!colorCandidateString.match(/^[A-Fa-f0-9]+$/)) { // verify if candidate consists only of allowed HEX characters
+                            error("Invalid HEX color code");
+                        }
                         return new(tree.Color)(rgb[1]);
                     }
                 },
@@ -1038,8 +1043,8 @@ less.Parser = function Parser(env) {
             rulesetCall: function () {
                 var name;
 
-                if (input.charAt(i) === '@' && (name = $re(/^(@[\w-]+)\s*\(\s*\)\s*;/))) { 
-                    return new tree.RulesetCall(name[1]); 
+                if (input.charAt(i) === '@' && (name = $re(/^(@[\w-]+)\s*\(\s*\)\s*;/))) {
+                    return new tree.RulesetCall(name[1]);
                 }
             },
 
@@ -1061,12 +1066,13 @@ less.Parser = function Parser(env) {
                     }
 
                     option = option && option[1];
-
+                    if (!elements)
+                        error("Missing target selector for :extend().");
                     extend = new(tree.Extend)(new(tree.Selector)(elements), option, index);
                     if (extendList) { extendList.push(extend); } else { extendList = [ extend ]; }
 
                 } while($char(","));
-                
+
                 expect(/^\)/);
 
                 if (isRule) {
@@ -1082,7 +1088,7 @@ less.Parser = function Parser(env) {
             extendRule: function() {
                 return this.extend(true);
             },
-            
+
             //
             // Mixins
             //
@@ -1288,7 +1294,7 @@ less.Parser = function Parser(env) {
                         variadic = argInfo.variadic;
 
                         // .mixincall("@{a}");
-                        // looks a bit like a mixin definition.. 
+                        // looks a bit like a mixin definition..
                         // also
                         // .mixincall(@a: {rule: set;});
                         // so we have to be nice and restore
@@ -1297,7 +1303,7 @@ less.Parser = function Parser(env) {
                             restore();
                             return;
                         }
-                        
+
                         parsers.comments();
 
                         if ($re(/^when/)) { // Guard
@@ -1404,10 +1410,20 @@ 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++;
                     }
@@ -1497,7 +1513,7 @@ less.Parser = function Parser(env) {
                 }
                 return block;
             },
-            
+
             detachedRuleset: function() {
                 var blockRuleset = this.blockRuleset();
                 if (blockRuleset) {
@@ -1510,7 +1526,7 @@ less.Parser = function Parser(env) {
             //
             ruleset: function () {
                 var selectors, s, rules, debugInfo;
-                
+
                 save();
 
                 if (env.dumpLineNumbers) {
@@ -1557,20 +1573,21 @@ less.Parser = function Parser(env) {
                 name = this.variable() || this.ruleProperty();
                 if (name) {
                     isVariable = typeof name === "string";
-                    
+
                     if (isVariable) {
                         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
                         value = !tryAnonymous && (env.compress || isVariable) ?
                             (this.value() || this.anonymousValue()) :
                             (this.anonymousValue() || this.value());
-    
+
                         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
@@ -1605,7 +1622,7 @@ less.Parser = function Parser(env) {
             //
             //     @import "lib";
             //
-            // Depending on our environemnt, importing is done differently:
+            // Depending on our environment, importing is done differently:
             // In the browser, it's an XHR request, in Node, it would be a
             // file-system operation. The function used for importing is
             // stored in `import`, which we pass to the Import constructor.
@@ -1613,22 +1630,27 @@ less.Parser = function Parser(env) {
             "import": function () {
                 var path, features, index = i;
 
-                save();
-
                 var dir = $re(/^@import?\s+/);
 
-                var options = (dir ? this.importOptions() : null) || {};
+                if (dir) {
+                    var options = (dir ? this.importOptions() : null) || {};
 
-                if (dir && (path = this.entities.quoted() || this.entities.url())) {
-                    features = this.mediaFeatures();
-                    if ($char(';')) {
-                        forget();
+                    if ((path = this.entities.quoted() || this.entities.url())) {
+                        features = this.mediaFeatures();
+
+                        if (!$(';')) {
+                            i = index;
+                            error("missing semi-colon or unrecognised media features on import");
+                        }
                         features = features && new(tree.Value)(features);
                         return new(tree.Import)(path, features, options, index, env.currentFileInfo);
                     }
+                    else
+                    {
+                        i = index;
+                        error("malformed import statement");
+                    }
                 }
-
-                restore();
             },
 
             importOptions: function() {
@@ -1751,7 +1773,7 @@ less.Parser = function Parser(env) {
                 save();
 
                 name = $re(/^@[a-z-]+/);
-                
+
                 if (!name) { return; }
 
                 nonVendorSpecificName = name;
@@ -1801,6 +1823,8 @@ less.Parser = function Parser(env) {
                         break;
                 }
 
+                this.comments();
+
                 if (hasIdentifier) {
                     value = this.entity();
                     if (!value) {
@@ -1818,13 +1842,15 @@ less.Parser = function Parser(env) {
                     }
                 }
 
+                this.comments();
+
                 if (hasBlock) {
                     rules = this.blockRuleset();
                 }
 
                 if (rules || (!hasBlock && value && $char(';'))) {
                     forget();
-                    return new(tree.Directive)(name, value, rules, index, env.currentFileInfo, 
+                    return new(tree.Directive)(name, value, rules, index, env.currentFileInfo,
                         env.dumpLineNumbers ? getDebugInfo(index, input, env) : null);
                 }
 
@@ -1881,13 +1907,17 @@ less.Parser = function Parser(env) {
                         if (peek(/^\/[*\/]/)) {
                             break;
                         }
+
+                        save();
+
                         op = $char('/') || $char('*');
 
-                        if (!op) { break; }
+                        if (!op) { forget(); break; }
 
                         a = this.operand();
 
-                        if (!a) { break; }
+                        if (!a) { restore(); break; }
+                        forget();
 
                         m.parensInOp = true;
                         a.parensInOp = true;
@@ -1911,7 +1941,7 @@ less.Parser = function Parser(env) {
                         if (!a) {
                             break;
                         }
-                        
+
                         m.parensInOp = true;
                         a.parensInOp = true;
                         operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
@@ -2018,7 +2048,7 @@ less.Parser = function Parser(env) {
             },
             ruleProperty: function () {
                 var c = current, name = [], index = [], length = 0, s, k;
-                
+
                 function match(re) {
                     var a = re.exec(c);
                     if (a) {
@@ -2028,11 +2058,22 @@ 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, 
+                    // at last, we have the complete match now. move forward,
                     // convert name particles to tree objects and return:
                     skipWhitespace(length);
                     if (name[0] === '') {
@@ -2043,7 +2084,7 @@ less.Parser = function Parser(env) {
                         s = name[k];
                         name[k] = (s.charAt(0) !== '@')
                             ? new(tree.Keyword)(s)
-                            : new(tree.Variable)('@' + s.slice(2, -1), 
+                            : new(tree.Variable)('@' + s.slice(2, -1),
                                 index[k], env.currentFileInfo);
                     }
                     return name;

package/lib/less/rhino.js

@@ -56,7 +56,8 @@ function formatError(ctx, options) {
 function writeError(ctx, options) {
     options = options || {};
     if (options.silent) { return; }
-    print(formatError(ctx, options));
+    var message = formatError(ctx, options);
+    throw new Error(message);
 }
 
 function loadStyleSheet(sheet, callback, reload, remaining) {
@@ -203,7 +204,7 @@ function writeFile(filename, content) {
         switch (arg) {
             case 'v':
             case 'version':
-                console.log("lessc " + less.version.join('.') + " (LESS Compiler) [JavaScript]");
+                console.log("lessc " + less.version.join('.') + " (Less Compiler) [JavaScript]");
                 continueProcessing = false;
                 break;
             case 'verbose':
@@ -444,5 +445,4 @@ function writeFile(filename, content) {
         writeError(e, options);
         quit(1);
     }
-    console.log("done");
 }(arguments));

package/lib/less/source-map-output.js

@@ -127,7 +127,7 @@
             if (this._writeSourceMap) {
                 this._writeSourceMap(sourceMapContent);
             } else {
-                sourceMapURL = "data:application/json," + encodeURIComponent(sourceMapContent);
+                sourceMapURL = "data:application/json;base64," + require('./encoder.js').encodeBase64(sourceMapContent);
             }
 
             if (sourceMapURL) {

package/lib/less/to-css-visitor.js

@@ -63,6 +63,9 @@
                 }
                 this.charset = true;
             }
+            if (directiveNode.rules && directiveNode.rules.rules) {
+                this._mergeRules(directiveNode.rules.rules);
+            }
             return directiveNode;
         },
 

package/lib/less/tree/anonymous.js

@@ -1,15 +1,16 @@
 (function (tree) {
 
-tree.Anonymous = function (string, index, currentFileInfo, mapLines) {
-    this.value = string.value || string;
+tree.Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike) {
+    this.value = value;
     this.index = index;
     this.mapLines = mapLines;
     this.currentFileInfo = currentFileInfo;
+    this.rulesetLike = (typeof rulesetLike === 'undefined')? false : rulesetLike;
 };
 tree.Anonymous.prototype = {
     type: "Anonymous",
     eval: function () { 
-        return new tree.Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines);
+        return new tree.Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines, this.rulesetLike);
     },
     compare: function (x) {
         if (!x.toCSS) {
@@ -25,6 +26,9 @@ tree.Anonymous.prototype = {
         
         return left < right ? -1 : 1;
     },
+    isRulesetLike: function() {
+        return this.rulesetLike;
+    },
     genCSS: function (env, output) {
         output.add(this.value, this.currentFileInfo, this.index, this.mapLines);
     },

package/lib/less/tree/directive.js

@@ -23,6 +23,12 @@ tree.Directive.prototype = {
             value = visitor.visit(value);
         }
     },
+    isRulesetLike: function() {
+        return !this.isCharset();
+    },
+    isCharset: function() {
+        return "@charset" === this.name;
+    },
     genCSS: function (env, output) {
         var value = this.value, rules = this.rules;
         output.add(this.name, this.currentFileInfo, this.index);

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/import.js

@@ -103,7 +103,7 @@ tree.Import.prototype = {
          
         if (this.options.inline) {
             //todo needs to reference css file not import
-            var contents = new(tree.Anonymous)(this.root, 0, {filename: this.importedFilename}, true);
+            var contents = new(tree.Anonymous)(this.root, 0, {filename: this.importedFilename}, true, true);
             return this.features ? new(tree.Media)([contents], this.features.value) : [contents];
         } else if (this.css) {
             var newImport = new(tree.Import)(this.evalPath(env), features, this.options, this.index);

package/lib/less/tree/mixin.js

@@ -21,7 +21,7 @@ tree.mixin.Call.prototype = {
     eval: function (env) {
         var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound, rule,
             candidates = [], candidate, conditionResult = [], defaultFunc = tree.defaultFunc,
-            defaultResult, defNone = 0, defTrue = 1, defFalse = 2, count; 
+            defaultResult, defNone = 0, defTrue = 1, defFalse = 2, count, originalRuleset; 
 
         args = this.arguments && this.arguments.map(function (a) {
             return { name: a.name, value: a.value.eval(env) };
@@ -99,8 +99,9 @@ tree.mixin.Call.prototype = {
                         try {
                             mixin = candidates[m].mixin;
                             if (!(mixin instanceof tree.mixin.Definition)) {
+                                originalRuleset = mixin.originalRuleset || mixin;
                                 mixin = new tree.mixin.Definition("", [], mixin.rules, null, false);
-                                mixin.originalRuleset = mixins[m].originalRuleset || mixins[m];
+                                mixin.originalRuleset = originalRuleset;
                             }
                             Array.prototype.push.apply(
                                   rules, mixin.evalCall(env, args, this.important).rules);
@@ -282,7 +283,7 @@ tree.mixin.Definition.prototype = {
     matchCondition: function (args, env) {
         if (this.condition && !this.condition.eval(
             new(tree.evalEnv)(env,
-                [this.evalParams(env, new(tree.evalEnv)(env, this.frames.concat(env.frames)), args, [])] // the parameter variables
+                [this.evalParams(env, new(tree.evalEnv)(env, this.frames ? this.frames.concat(env.frames) : env.frames), args, [])] // the parameter variables
                     .concat(this.frames) // the parent namespace/mixin frames
                     .concat(env.frames)))) { // the current environment frames
             return false;

package/lib/less/tree/quoted.js

@@ -33,14 +33,22 @@ tree.Quoted.prototype = {
         if (!x.toCSS) {
             return -1;
         }
-        
-        var left = this.toCSS(),
+
+        var left, right;
+
+        // when comparing quoted strings allow the quote to differ
+        if (x.type === "Quoted" && !this.escaped && !x.escaped) {
+            left = x.value;
+            right = this.value;
+        } else {
+            left = this.toCSS();
             right = x.toCSS();
-        
+        }
+
         if (left === right) {
             return 0;
         }
-        
+
         return left < right ? -1 : 1;
     }
 };

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') {