less 2.4.0 → 2.5.0

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

@@ -9,13 +9,21 @@ tree.Alpha.prototype = {
         this.value = visitor.visit(this.value);
     },
     eval: function (env) {
-        if (this.value.eval) { this.value = this.value.eval(env) }
+        if (this.value.eval) { return new tree.Alpha(this.value.eval(env)); }
         return this;
     },
-    toCSS: function () {
-        return "alpha(opacity=" +
-               (this.value.toCSS ? this.value.toCSS() : this.value) + ")";
-    }
+    genCSS: function (env, output) {
+        output.add("alpha(opacity=");
+
+        if (this.value.genCSS) {
+            this.value.genCSS(env, output);
+        } else {
+            output.add(this.value);
+        }
+
+        output.add(")");
+    },
+    toCSS: tree.toCSS
 };
 
 })(require('../tree'));

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

@@ -1,14 +1,16 @@
 (function (tree) {
 
-tree.Anonymous = function (string) {
+tree.Anonymous = function (string, index, currentFileInfo, mapLines) {
     this.value = string.value || string;
+    this.index = index;
+    this.mapLines = mapLines;
+    this.currentFileInfo = currentFileInfo;
 };
 tree.Anonymous.prototype = {
     type: "Anonymous",
-    toCSS: function () {
-        return this.value;
+    eval: function () { 
+        return new tree.Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines);
     },
-    eval: function () { return this },
     compare: function (x) {
         if (!x.toCSS) {
             return -1;
@@ -22,7 +24,11 @@ tree.Anonymous.prototype = {
         }
         
         return left < right ? -1 : 1;
-    }
+    },
+    genCSS: function (env, output) {
+        output.add(this.value, this.currentFileInfo, this.index, this.mapLines);
+    },
+    toCSS: tree.toCSS
 };
 
 })(require('../tree'));

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

@@ -9,15 +9,21 @@ tree.Assignment.prototype = {
     accept: function (visitor) {
         this.value = visitor.visit(this.value);
     },
-    toCSS: function () {
-        return this.key + '=' + (this.value.toCSS ? this.value.toCSS() : this.value);
-    },
     eval: function (env) {
         if (this.value.eval) {
             return new(tree.Assignment)(this.key, this.value.eval(env));
         }
         return this;
-    }
+    },
+    genCSS: function (env, output) {
+        output.add(this.key + '=');
+        if (this.value.genCSS) {
+            this.value.genCSS(env, output);
+        } else {
+            output.add(this.value);
+        }
+    },
+    toCSS: tree.toCSS
 };
 
-})(require('../tree'));
+})(require('../tree'));

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

@@ -12,7 +12,9 @@ tree.Call = function (name, args, index, currentFileInfo) {
 tree.Call.prototype = {
     type: "Call",
     accept: function (visitor) {
-        this.args = visitor.visit(this.args);
+        if (this.args) {
+            this.args = visitor.visitArray(this.args);
+        }
     },
     //
     // When evaluating a function call,
@@ -46,15 +48,24 @@ tree.Call.prototype = {
                         index: this.index, filename: this.currentFileInfo.filename };
             }
         }
-        
-        // 2.
-        return new(tree.Anonymous)(this.name +
-            "(" + args.map(function (a) { return a.toCSS(env); }).join(', ') + ")");
+
+        return new tree.Call(this.name, args, this.index, this.currentFileInfo);
+    },
+
+    genCSS: function (env, output) {
+        output.add(this.name + "(", this.currentFileInfo, this.index);
+
+        for(var i = 0; i < this.args.length; i++) {
+            this.args[i].genCSS(env, output);
+            if (i + 1 < this.args.length) {
+                output.add(", ");
+            }
+        }
+
+        output.add(")");
     },
 
-    toCSS: function (env) {
-        return this.eval(env).toCSS();
-    }
+    toCSS: tree.toCSS
 };
 
 })(require('../tree'));

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

@@ -22,42 +22,46 @@ tree.Color = function (rgb, a) {
     }
     this.alpha = typeof(a) === 'number' ? a : 1;
 };
+
+var transparentKeyword = "transparent";
+
 tree.Color.prototype = {
     type: "Color",
-    eval: function () { return this },
+    eval: function () { return this; },
     luma: function () { return (0.2126 * this.rgb[0] / 255) + (0.7152 * this.rgb[1] / 255) + (0.0722 * this.rgb[2] / 255); },
 
-    //
-    // If we have some transparency, the only way to represent it
-    // is via `rgba`. Otherwise, we use the hex representation,
-    // which has better compatibility with older browsers.
-    // Values are capped between `0` and `255`, rounded and zero-padded.
-    //
+    genCSS: function (env, output) {
+        output.add(this.toCSS(env));
+    },
     toCSS: function (env, doNotCompress) {
-        var compress = env && env.compress && !doNotCompress;
-        if (this.alpha < 1.0) {
+        var compress = env && env.compress && !doNotCompress,
+            alpha = tree.fround(env, this.alpha);
+
+        // If we have some transparency, the only way to represent it
+        // is via `rgba`. Otherwise, we use the hex representation,
+        // which has better compatibility with older browsers.
+        // Values are capped between `0` and `255`, rounded and zero-padded.
+        if (alpha < 1) {
+            if (alpha === 0 && this.isTransparentKeyword) {
+                return transparentKeyword;
+            }
             return "rgba(" + this.rgb.map(function (c) {
-                return Math.round(c);
-            }).concat(this.alpha).join(',' + (compress ? '' : ' ')) + ")";
+                return clamp(Math.round(c), 255);
+            }).concat(clamp(alpha, 1))
+                .join(',' + (compress ? '' : ' ')) + ")";
         } else {
-            var color = this.rgb.map(function (i) {
-                i = Math.round(i);
-                i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16);
-                return i.length === 1 ? '0' + i : i;
-            }).join('');
+            var color = this.toRGB();
 
             if (compress) {
-                color = color.split('');
+                var splitcolor = color.split('');
 
                 // Convert color to short format
-                if (color[0] == color[1] && color[2] == color[3] && color[4] == color[5]) {
-                    color = color[0] + color[2] + color[4];
-                } else {
-                    color = color.join('');
+                if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
+                    color = '#' + splitcolor[1] + splitcolor[3] + splitcolor[5];
                 }
             }
 
-            return '#' + color;
+            return color;
         }
     },
 
@@ -68,16 +72,16 @@ tree.Color.prototype = {
     // we create a new Color node to hold the result.
     //
     operate: function (env, op, other) {
-        var result = [];
-
-        if (! (other instanceof tree.Color)) {
-            other = other.toColor();
-        }
-
+        var rgb = [];
+        var alpha = this.alpha * (1 - other.alpha) + other.alpha;
         for (var c = 0; c < 3; c++) {
-            result[c] = tree.operate(env, op, this.rgb[c], other.rgb[c]);
+            rgb[c] = tree.operate(env, op, this.rgb[c], other.rgb[c]);
         }
-        return new(tree.Color)(result, this.alpha + other.alpha);
+        return new(tree.Color)(rgb, alpha);
+    },
+
+    toRGB: function () {
+        return toHex(this.rgb);
     },
 
     toHSL: function () {
@@ -133,12 +137,7 @@ tree.Color.prototype = {
         return { h: h * 360, s: s, v: v, a: a };
     },
     toARGB: function () {
-        var argb = [Math.round(this.alpha * 255)].concat(this.rgb);
-        return '#' + argb.map(function (i) {
-            i = Math.round(i);
-            i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16);
-            return i.length === 1 ? '0' + i : i;
-        }).join('');
+        return toHex([this.alpha * 255].concat(this.rgb));
     },
     compare: function (x) {
         if (!x.rgb) {
@@ -152,5 +151,29 @@ tree.Color.prototype = {
     }
 };
 
+tree.Color.fromKeyword = function(keyword) {
+    keyword = keyword.toLowerCase();
+
+    if (tree.colors.hasOwnProperty(keyword)) {
+        // detect named color
+        return new(tree.Color)(tree.colors[keyword].slice(1));
+    }
+    if (keyword === transparentKeyword) {
+        var transparent = new(tree.Color)([0, 0, 0], 0);
+        transparent.isTransparentKeyword = true;
+        return transparent;
+    }
+};
+
+function toHex(v) {
+    return '#' + v.map(function (c) {
+        c = clamp(Math.round(c), 255);
+        return (c < 16 ? '0' : '') + c.toString(16);
+    }).join('');
+}
+
+function clamp(v, max) {
+    return Math.min(Math.max(v, 0), max); 
+}
 
 })(require('../tree'));

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

@@ -1,15 +1,28 @@
 (function (tree) {
 
-tree.Comment = function (value, silent) {
+tree.Comment = function (value, silent, index, currentFileInfo) {
     this.value = value;
     this.silent = !!silent;
+    this.currentFileInfo = currentFileInfo;
 };
 tree.Comment.prototype = {
     type: "Comment",
-    toCSS: function (env) {
-        return env.compress ? '' : this.value;
+    genCSS: function (env, output) {
+        if (this.debugInfo) {
+            output.add(tree.debugInfo(env, this), this.currentFileInfo, this.index);
+        }
+        output.add(this.value.trim()); //TODO shouldn't need to trim, we shouldn't grab the \n
     },
-    eval: function () { return this }
+    toCSS: tree.toCSS,
+    isSilent: function(env) {
+        var isReference = (this.currentFileInfo && this.currentFileInfo.reference && !this.isReferenced),
+            isCompressed = env.compress && !this.value.match(/^\/\*!/);
+        return this.silent || isReference || isCompressed;
+    },
+    eval: function () { return this; },
+    markReferenced: function () {
+        this.isReferenced = true;
+    }
 };
 
 })(require('../tree'));

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

@@ -19,7 +19,7 @@ tree.Condition.prototype = {
 
         var i = this.index, result;
 
-        var result = (function (op) {
+        result = (function (op) {
             switch (op) {
                 case 'and':
                     return a && b;
@@ -36,8 +36,8 @@ tree.Condition.prototype = {
                                 index: i };
                     }
                     switch (result) {
-                        case -1: return op === '<' || op === '=<';
-                        case  0: return op === '=' || op === '>=' || op === '=<';
+                        case -1: return op === '<' || op === '=<' || op === '<=';
+                        case  0: return op === '=' || op === '>=' || op === '=<' || op === '<=';
                         case  1: return op === '>' || op === '>=';
                     }
             }

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

@@ -20,12 +20,12 @@ tree.Dimension.prototype = {
     toColor: function () {
         return new(tree.Color)([this.value, this.value, this.value]);
     },
-    toCSS: function (env) {
+    genCSS: function (env, output) {
         if ((env && env.strictUnits) && !this.unit.isSingular()) {
             throw new Error("Multiple units in dimension. Correct the units or use the unit function. Bad unit: "+this.unit.toString());
         }
 
-        var value = this.value,
+        var value = tree.fround(env, this.value),
             strValue = String(value);
 
         if (value !== 0 && value < 0.000001 && value > -0.000001) {
@@ -35,8 +35,9 @@ tree.Dimension.prototype = {
 
         if (env && env.compress) {
             // Zero values doesn't need a unit
-            if (value === 0 && !this.unit.isAngle()) {
-                return strValue;
+            if (value === 0 && this.unit.isLength()) {
+                output.add(strValue);
+                return;
             }
 
             // Float values doesn't need a leading zero
@@ -45,13 +46,16 @@ tree.Dimension.prototype = {
             }
         }
 
-        return strValue + this.unit.toCSS(env);
+        output.add(strValue);
+        this.unit.genCSS(env, output);
     },
+    toCSS: tree.toCSS,
 
     // In an operation between two Dimensions,
     // we default to the first Dimension's unit,
     // so `1px + 2` will yield `3px`.
     operate: function (env, op, other) {
+        /*jshint noempty:false */
         var value = tree.operate(env, op, this.value, other.value),
             unit = this.unit.clone();
 
@@ -59,7 +63,7 @@ tree.Dimension.prototype = {
             if (unit.numerator.length === 0 && unit.denominator.length === 0) {
                 unit.numerator = other.unit.numerator.slice(0);
                 unit.denominator = other.unit.denominator.slice(0);
-            } else if (other.unit.numerator.length == 0 && unit.denominator.length == 0) {
+            } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
                 // do nothing
             } else {
                 other = other.convertTo(this.unit.usedUnits());
@@ -104,202 +108,206 @@ tree.Dimension.prototype = {
     },
 
     unify: function () {
-      return this.convertTo({ length: 'm', duration: 's', angle: 'rad' });
+        return this.convertTo({ length: 'm', duration: 's', angle: 'rad' });
     },
 
     convertTo: function (conversions) {
-      var value = this.value, unit = this.unit.clone(),
-          i, groupName, group, conversion, targetUnit, derivedConversions = {};
-
-      if (typeof conversions === 'string') {
-          for(i in tree.UnitConversions) {
-              if (tree.UnitConversions[i].hasOwnProperty(conversions)) {
-                  derivedConversions = {};
-                  derivedConversions[i] = conversions;
-              }
-          }
-          conversions = derivedConversions;
-      }
-
-      for (groupName in conversions) {
-        if (conversions.hasOwnProperty(groupName)) {
-          targetUnit = conversions[groupName];
-          group = tree.UnitConversions[groupName];
-
-          unit.map(function (atomicUnit, denominator) {
+        var value = this.value, unit = this.unit.clone(),
+            i, groupName, group, targetUnit, derivedConversions = {}, applyUnit;
+
+        if (typeof conversions === 'string') {
+            for(i in tree.UnitConversions) {
+                if (tree.UnitConversions[i].hasOwnProperty(conversions)) {
+                    derivedConversions = {};
+                    derivedConversions[i] = conversions;
+                }
+            }
+            conversions = derivedConversions;
+        }
+        applyUnit = function (atomicUnit, denominator) {
+          /*jshint loopfunc:true */
             if (group.hasOwnProperty(atomicUnit)) {
-              if (denominator) {
-                value = value / (group[atomicUnit] / group[targetUnit]);
-              } else {
-                value = value * (group[atomicUnit] / group[targetUnit]);
-              }
+                if (denominator) {
+                    value = value / (group[atomicUnit] / group[targetUnit]);
+                } else {
+                    value = value * (group[atomicUnit] / group[targetUnit]);
+                }
 
-              return targetUnit;
+                return targetUnit;
             }
 
             return atomicUnit;
-          });
+        };
+
+        for (groupName in conversions) {
+            if (conversions.hasOwnProperty(groupName)) {
+                targetUnit = conversions[groupName];
+                group = tree.UnitConversions[groupName];
+
+                unit.map(applyUnit);
+            }
         }
-      }
 
-      unit.cancel();
+        unit.cancel();
 
-      return new(tree.Dimension)(value, unit);
+        return new(tree.Dimension)(value, unit);
     }
 };
 
 // http://www.w3.org/TR/css3-values/#absolute-lengths
 tree.UnitConversions = {
-  length: {
-     'm': 1,
-    'cm': 0.01,
-    'mm': 0.001,
-    'in': 0.0254,
-    'pt': 0.0254 / 72,
-    'pc': 0.0254 / 72 * 12
-  },
-  duration: {
-    's': 1,
-    'ms': 0.001
-  },
-  angle: {
-    'rad': 1/(2*Math.PI),
-    'deg': 1/360,
-    'grad': 1/400,
-    'turn': 1
-  }
+    length: {
+         'm': 1,
+        'cm': 0.01,
+        'mm': 0.001,
+        'in': 0.0254,
+        'pt': 0.0254 / 72,
+        'pc': 0.0254 / 72 * 12
+    },
+    duration: {
+        's': 1,
+        'ms': 0.001
+    },
+    angle: {
+        'rad': 1/(2*Math.PI),
+        'deg': 1/360,
+        'grad': 1/400,
+        'turn': 1
+    }
 };
 
 tree.Unit = function (numerator, denominator, backupUnit) {
-  this.numerator = numerator ? numerator.slice(0).sort() : [];
-  this.denominator = denominator ? denominator.slice(0).sort() : [];
-  this.backupUnit = backupUnit;
+    this.numerator = numerator ? numerator.slice(0).sort() : [];
+    this.denominator = denominator ? denominator.slice(0).sort() : [];
+    this.backupUnit = backupUnit;
 };
 
 tree.Unit.prototype = {
-  type: "Unit",
-  clone: function () {
-    return new tree.Unit(this.numerator.slice(0), this.denominator.slice(0), this.backupUnit);
-  },
-
-  toCSS: function (env) {
-    if (this.numerator.length >= 1) {
-        return this.numerator[0];
-    }
-    if (this.denominator.length >= 1) {
-        return this.denominator[0];
-    }
-    if ((!env || !env.strictUnits) && this.backupUnit) {
-        return this.backupUnit;
-    }
-    return "";
-  },
+    type: "Unit",
+    clone: function () {
+        return new tree.Unit(this.numerator.slice(0), this.denominator.slice(0), this.backupUnit);
+    },
+    genCSS: function (env, output) {
+        if (this.numerator.length >= 1) {
+            output.add(this.numerator[0]);
+        } else
+        if (this.denominator.length >= 1) {
+            output.add(this.denominator[0]);
+        } else
+        if ((!env || !env.strictUnits) && this.backupUnit) {
+            output.add(this.backupUnit);
+        }
+    },
+    toCSS: tree.toCSS,
 
-  toString: function () {
+    toString: function () {
       var i, returnStr = this.numerator.join("*");
       for (i = 0; i < this.denominator.length; i++) {
           returnStr += "/" + this.denominator[i];
       }
       return returnStr;
-  },
-  
-  compare: function (other) {
-    return this.is(other.toString()) ? 0 : -1;
-  },
+    },
 
-  is: function (unitString) {
-    return this.toString() === unitString;
-  },
+    compare: function (other) {
+        return this.is(other.toString()) ? 0 : -1;
+    },
 
-  isAngle: function () {
-    return tree.UnitConversions.angle.hasOwnProperty(this.toCSS());
-  },
+    is: function (unitString) {
+        return this.toString() === unitString;
+    },
 
-  isEmpty: function () {
-    return this.numerator.length == 0 && this.denominator.length == 0;
-  },
+    isLength: function () {
+        return Boolean(this.toCSS().match(/px|em|%|in|cm|mm|pc|pt|ex/));
+    },
 
-  isSingular: function() {
-      return this.numerator.length <= 1 && this.denominator.length == 0;
-  },
+    isEmpty: function () {
+        return this.numerator.length === 0 && this.denominator.length === 0;
+    },
 
-  map: function(callback) {
-    var i;
+    isSingular: function() {
+        return this.numerator.length <= 1 && this.denominator.length === 0;
+    },
 
-    for (i = 0; i < this.numerator.length; i++) {
-      this.numerator[i] = callback(this.numerator[i], false);
-    }
+    map: function(callback) {
+        var i;
 
-    for (i = 0; i < this.denominator.length; i++) {
-      this.denominator[i] = callback(this.denominator[i], true);
-    }
-  },
+        for (i = 0; i < this.numerator.length; i++) {
+            this.numerator[i] = callback(this.numerator[i], false);
+        }
 
-  usedUnits: function() {
-    var group, groupName, result = {};
+        for (i = 0; i < this.denominator.length; i++) {
+            this.denominator[i] = callback(this.denominator[i], true);
+        }
+    },
 
-    for (groupName in tree.UnitConversions) {
-      if (tree.UnitConversions.hasOwnProperty(groupName)) {
-        group = tree.UnitConversions[groupName];
+    usedUnits: function() {
+        var group, result = {}, mapUnit;
 
-        this.map(function (atomicUnit) {
-          if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
-            result[groupName] = atomicUnit;
-          }
+        mapUnit = function (atomicUnit) {
+        /*jshint loopfunc:true */
+            if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
+                result[groupName] = atomicUnit;
+            }
 
-          return atomicUnit;
-        });
-      }
-    }
+            return atomicUnit;
+        };
+
+        for (var groupName in tree.UnitConversions) {
+            if (tree.UnitConversions.hasOwnProperty(groupName)) {
+                group = tree.UnitConversions[groupName];
+
+                this.map(mapUnit);
+            }
+        }
 
-    return result;
-  },
+        return result;
+    },
 
-  cancel: function () {
-    var counter = {}, atomicUnit, i, backup;
+    cancel: function () {
+        var counter = {}, atomicUnit, i, backup;
 
-    for (i = 0; i < this.numerator.length; i++) {
-        atomicUnit = this.numerator[i];
-        if (!backup) {
-            backup = atomicUnit;
+        for (i = 0; i < this.numerator.length; i++) {
+            atomicUnit = this.numerator[i];
+            if (!backup) {
+                backup = atomicUnit;
+            }
+            counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
         }
-        counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
-    }
 
-    for (i = 0; i < this.denominator.length; i++) {
-        atomicUnit = this.denominator[i];
-        if (!backup) {
-            backup = atomicUnit;
+        for (i = 0; i < this.denominator.length; i++) {
+            atomicUnit = this.denominator[i];
+            if (!backup) {
+                backup = atomicUnit;
+            }
+            counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
         }
-        counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
-    }
 
-    this.numerator = [];
-    this.denominator = [];
-
-    for (atomicUnit in counter) {
-      if (counter.hasOwnProperty(atomicUnit)) {
-        var count = counter[atomicUnit];
-
-        if (count > 0) {
-          for (i = 0; i < count; i++) {
-            this.numerator.push(atomicUnit);
-          }
-        } else if (count < 0) {
-          for (i = 0; i < -count; i++) {
-            this.denominator.push(atomicUnit);
-          }
+        this.numerator = [];
+        this.denominator = [];
+
+        for (atomicUnit in counter) {
+            if (counter.hasOwnProperty(atomicUnit)) {
+                var count = counter[atomicUnit];
+
+                if (count > 0) {
+                    for (i = 0; i < count; i++) {
+                        this.numerator.push(atomicUnit);
+                    }
+                } else if (count < 0) {
+                    for (i = 0; i < -count; i++) {
+                        this.denominator.push(atomicUnit);
+                    }
+                }
+            }
         }
-      }
-    }
 
-    if (this.numerator.length === 0 && this.denominator.length === 0 && backup) {
-        this.backupUnit = backup;
-    }
+        if (this.numerator.length === 0 && this.denominator.length === 0 && backup) {
+            this.backupUnit = backup;
+        }
 
-    this.numerator.sort();
-    this.denominator.sort();
-  }
+        this.numerator.sort();
+        this.denominator.sort();
+    }
 };
 
 })(require('../tree'));