less 2.3.3 → 2.4.0

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

@@ -5,6 +5,8 @@ function loadStyleSheet(sheet, callback, reload, remaining) {
         sheetName = name.slice(0, endOfPath + 1) + sheet.href,
         contents = sheet.contents || {},
         input = readFile(sheetName);
+
+    input = input.replace(/^\xEF\xBB\xBF/, '');
         
     contents[sheetName] = input;
         
@@ -35,7 +37,8 @@ function writeFile(filename, content) {
 (function (args) {
     var output,
         compress = false,
-        i;
+        i,
+        path;
         
     for(i = 0; i < args.length; i++) {
         switch(args[i]) {
@@ -119,5 +122,5 @@ function error(e, filename) {
         errorline(e, 1);
         errorline(e, 2);
     }
-   print(content);
+    print(content);
 }

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

@@ -24,7 +24,7 @@ tree.debugInfo.asComment = function(ctx) {
 
 tree.debugInfo.asMediaQuery = function(ctx) {
     return '@media -sass-debug-info{filename{font-family:' +
-        ('file://' + ctx.debugInfo.fileName).replace(/[\/:.]/g, '\\$&') +
+        ('file://' + ctx.debugInfo.fileName).replace(/([.:/\\])/g, function(a){if(a=='\\') a = '\/'; return '\\' + a}) +
         '}line{font-family:\\00003' + ctx.debugInfo.lineNumber + '}}\n';
 };
 

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

@@ -4,13 +4,17 @@ tree.Alpha = function (val) {
     this.value = val;
 };
 tree.Alpha.prototype = {
-    toCSS: function () {
-        return "alpha(opacity=" +
-               (this.value.toCSS ? this.value.toCSS() : this.value) + ")";
+    type: "Alpha",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
     },
     eval: function (env) {
         if (this.value.eval) { this.value = this.value.eval(env) }
         return this;
+    },
+    toCSS: function () {
+        return "alpha(opacity=" +
+               (this.value.toCSS ? this.value.toCSS() : this.value) + ")";
     }
 };
 

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

@@ -4,6 +4,7 @@ tree.Anonymous = function (string) {
     this.value = string.value || string;
 };
 tree.Anonymous.prototype = {
+    type: "Anonymous",
     toCSS: function () {
         return this.value;
     },

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

@@ -5,6 +5,10 @@ tree.Assignment = function (key, val) {
     this.value = val;
 };
 tree.Assignment.prototype = {
+    type: "Assignment",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
     toCSS: function () {
         return this.key + '=' + (this.value.toCSS ? this.value.toCSS() : this.value);
     },

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

@@ -3,13 +3,17 @@
 //
 // A function call node.
 //
-tree.Call = function (name, args, index, filename) {
+tree.Call = function (name, args, index, currentFileInfo) {
     this.name = name;
     this.args = args;
     this.index = index;
-    this.filename = filename;
+    this.currentFileInfo = currentFileInfo;
 };
 tree.Call.prototype = {
+    type: "Call",
+    accept: function (visitor) {
+        this.args = visitor.visit(this.args);
+    },
     //
     // When evaluating a function call,
     // we either find the function in `tree.functions` [1],
@@ -24,12 +28,14 @@ tree.Call.prototype = {
     // The function should receive the value, not the variable.
     //
     eval: function (env) {
-        var args = this.args.map(function (a) { return a.eval(env) }),
-            result;
+        var args = this.args.map(function (a) { return a.eval(env); }),
+            nameLC = this.name.toLowerCase(),
+            result, func;
 
-        if (this.name in tree.functions) { // 1.
+        if (nameLC in tree.functions) { // 1.
             try {
-                result = tree.functions[this.name].apply(tree.functions, args);
+                func = new tree.functionCall(env, this.currentFileInfo);
+                result = func[nameLC].apply(func, args);
                 if (result != null) {
                     return result;
                 }
@@ -37,13 +43,13 @@ tree.Call.prototype = {
                 throw { type: e.type || "Runtime",
                         message: "error evaluating function `" + this.name + "`" +
                                  (e.message ? ': ' + e.message : ''),
-                        index: this.index, filename: this.filename };
+                        index: this.index, filename: this.currentFileInfo.filename };
             }
         }
         
         // 2.
         return new(tree.Anonymous)(this.name +
-            "(" + args.map(function (a) { return a.toCSS(env) }).join(', ') + ")");
+            "(" + args.map(function (a) { return a.toCSS(env); }).join(', ') + ")");
     },
 
     toCSS: function (env) {

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

@@ -23,7 +23,9 @@ tree.Color = function (rgb, a) {
     this.alpha = typeof(a) === 'number' ? a : 1;
 };
 tree.Color.prototype = {
+    type: "Color",
     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
@@ -31,17 +33,31 @@ tree.Color.prototype = {
     // which has better compatibility with older browsers.
     // Values are capped between `0` and `255`, rounded and zero-padded.
     //
-    toCSS: function () {
+    toCSS: function (env, doNotCompress) {
+        var compress = env && env.compress && !doNotCompress;
         if (this.alpha < 1.0) {
             return "rgba(" + this.rgb.map(function (c) {
                 return Math.round(c);
-            }).concat(this.alpha).join(', ') + ")";
+            }).concat(this.alpha).join(',' + (compress ? '' : ' ')) + ")";
         } else {
-            return '#' + this.rgb.map(function (i) {
+            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('');
+
+            if (compress) {
+                color = 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('');
+                }
+            }
+
+            return '#' + color;
         }
     },
 
@@ -51,7 +67,7 @@ tree.Color.prototype = {
     // our result, in the form of an integer triplet,
     // we create a new Color node to hold the result.
     //
-    operate: function (op, other) {
+    operate: function (env, op, other) {
         var result = [];
 
         if (! (other instanceof tree.Color)) {
@@ -59,7 +75,7 @@ tree.Color.prototype = {
         }
 
         for (var c = 0; c < 3; c++) {
-            result[c] = tree.operate(op, this.rgb[c], other.rgb[c]);
+            result[c] = tree.operate(env, op, this.rgb[c], other.rgb[c]);
         }
         return new(tree.Color)(result, this.alpha + other.alpha);
     },
@@ -87,6 +103,35 @@ tree.Color.prototype = {
         }
         return { h: h * 360, s: s, l: l, a: a };
     },
+    //Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+    toHSV: function () {
+        var r = this.rgb[0] / 255,
+            g = this.rgb[1] / 255,
+            b = this.rgb[2] / 255,
+            a = this.alpha;
+
+        var max = Math.max(r, g, b), min = Math.min(r, g, b);
+        var h, s, v = max;
+
+        var d = max - min;
+        if (max === 0) {
+            s = 0;
+        } else {
+            s = d / max;
+        }
+
+        if (max === min) {
+            h = 0;
+        } else {
+            switch(max){
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
+            }
+            h /= 6;
+        }
+        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) {

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

@@ -5,6 +5,7 @@ tree.Comment = function (value, silent) {
     this.silent = !!silent;
 };
 tree.Comment.prototype = {
+    type: "Comment",
     toCSS: function (env) {
         return env.compress ? '' : this.value;
     },

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

@@ -7,36 +7,43 @@ tree.Condition = function (op, l, r, i, negate) {
     this.index = i;
     this.negate = negate;
 };
-tree.Condition.prototype.eval = function (env) {
-    var a = this.lvalue.eval(env),
-        b = this.rvalue.eval(env);
+tree.Condition.prototype = {
+    type: "Condition",
+    accept: function (visitor) {
+        this.lvalue = visitor.visit(this.lvalue);
+        this.rvalue = visitor.visit(this.rvalue);
+    },
+    eval: function (env) {
+        var a = this.lvalue.eval(env),
+            b = this.rvalue.eval(env);
 
-    var i = this.index, result;
+        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;
+        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

@@ -5,39 +5,95 @@
 //
 tree.Dimension = function (value, unit) {
     this.value = parseFloat(value);
-    this.unit = unit || null;
+    this.unit = (unit && unit instanceof tree.Unit) ? unit :
+      new(tree.Unit)(unit ? [unit] : undefined);
 };
 
 tree.Dimension.prototype = {
-    eval: function () { return this },
+    type: "Dimension",
+    accept: function (visitor) {
+        this.unit = visitor.visit(this.unit);
+    },
+    eval: function (env) {
+        return this;
+    },
     toColor: function () {
         return new(tree.Color)([this.value, this.value, this.value]);
     },
-    toCSS: function () {
-        var css = this.value + this.unit;
-        return css;
+    toCSS: function (env) {
+        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,
+            strValue = String(value);
+
+        if (value !== 0 && value < 0.000001 && value > -0.000001) {
+            // would be output 1e-6 etc.
+            strValue = value.toFixed(20).replace(/0+$/, "");
+        }
+
+        if (env && env.compress) {
+            // Zero values doesn't need a unit
+            if (value === 0 && !this.unit.isAngle()) {
+                return strValue;
+            }
+
+            // Float values doesn't need a leading zero
+            if (value > 0 && value < 1) {
+                strValue = (strValue).substr(1);
+            }
+        }
+
+        return strValue + this.unit.toCSS(env);
     },
 
     // In an operation between two Dimensions,
     // we default to the first Dimension's unit,
-    // so `1px + 2em` will yield `3px`.
-    // In the future, we could implement some unit
-    // conversions such that `100cm + 10mm` would yield
-    // `101cm`.
-    operate: function (op, other) {
-        return new(tree.Dimension)
-                  (tree.operate(op, this.value, other.value),
-                  this.unit || other.unit);
+    // so `1px + 2` will yield `3px`.
+    operate: function (env, op, other) {
+        var value = tree.operate(env, op, this.value, other.value),
+            unit = this.unit.clone();
+
+        if (op === '+' || op === '-') {
+            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) {
+                // do nothing
+            } else {
+                other = other.convertTo(this.unit.usedUnits());
+
+                if(env.strictUnits && other.unit.toString() !== unit.toString()) {
+                  throw new Error("Incompatible units. Change the units or use the unit function. Bad units: '" + unit.toString() +
+                    "' and '" + other.unit.toString() + "'.");
+                }
+
+                value = tree.operate(env, op, this.value, other.value);
+            }
+        } else if (op === '*') {
+            unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
+            unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
+            unit.cancel();
+        } else if (op === '/') {
+            unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
+            unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
+            unit.cancel();
+        }
+        return new(tree.Dimension)(value, unit);
     },
 
     compare: function (other) {
         if (other instanceof tree.Dimension) {
-            if (other.value > this.value) {
+            var a = this.unify(), b = other.unify(),
+                aValue = a.value, bValue = b.value;
+
+            if (bValue > aValue) {
                 return -1;
-            } else if (other.value < this.value) {
+            } else if (bValue < aValue) {
                 return 1;
             } else {
-                if (other.unit && this.unit !== other.unit) {
+                if (!b.unit.isEmpty() && a.unit.compare(b.unit) !== 0) {
                     return -1;
                 }
                 return 0;
@@ -45,7 +101,205 @@ tree.Dimension.prototype = {
         } else {
             return -1;
         }
+    },
+
+    unify: function () {
+      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) {
+            if (group.hasOwnProperty(atomicUnit)) {
+              if (denominator) {
+                value = value / (group[atomicUnit] / group[targetUnit]);
+              } else {
+                value = value * (group[atomicUnit] / group[targetUnit]);
+              }
+
+              return targetUnit;
+            }
+
+            return atomicUnit;
+          });
+        }
+      }
+
+      unit.cancel();
+
+      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
+  }
+};
+
+tree.Unit = function (numerator, denominator, 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 "";
+  },
+
+  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;
+  },
+
+  isAngle: function () {
+    return tree.UnitConversions.angle.hasOwnProperty(this.toCSS());
+  },
+
+  isEmpty: function () {
+    return this.numerator.length == 0 && this.denominator.length == 0;
+  },
+
+  isSingular: function() {
+      return this.numerator.length <= 1 && this.denominator.length == 0;
+  },
+
+  map: function(callback) {
+    var i;
+
+    for (i = 0; i < this.numerator.length; i++) {
+      this.numerator[i] = callback(this.numerator[i], false);
+    }
+
+    for (i = 0; i < this.denominator.length; i++) {
+      this.denominator[i] = callback(this.denominator[i], true);
+    }
+  },
+
+  usedUnits: function() {
+    var group, groupName, result = {};
+
+    for (groupName in tree.UnitConversions) {
+      if (tree.UnitConversions.hasOwnProperty(groupName)) {
+        group = tree.UnitConversions[groupName];
+
+        this.map(function (atomicUnit) {
+          if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
+            result[groupName] = atomicUnit;
+          }
+
+          return atomicUnit;
+        });
+      }
+    }
+
+    return result;
+  },
+
+  cancel: function () {
+    var counter = {}, atomicUnit, i, backup;
+
+    for (i = 0; i < this.numerator.length; i++) {
+        atomicUnit = this.numerator[i];
+        if (!backup) {
+            backup = atomicUnit;
+        }
+        counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
+    }
+
+    for (i = 0; i < this.denominator.length; i++) {
+        atomicUnit = this.denominator[i];
+        if (!backup) {
+            backup = atomicUnit;
+        }
+        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);
+          }
+        }
+      }
+    }
+
+    if (this.numerator.length === 0 && this.denominator.length === 0 && backup) {
+        this.backupUnit = backup;
+    }
+
+    this.numerator.sort();
+    this.denominator.sort();
+  }
 };
 
 })(require('../tree'));