less 2.2.2 → 2.6.0

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;
+        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 === '=<' || op === '<=';
+                        case  0: return op === '=' || op === '>=' || op === '=<' || op === '<=';
+                        case  1: return op === '>' || op === '>=';
+                    }
+            }
+        })(this.op);
+        return this.negate ? !result : result;
+    }
 };
 
 })(require('../tree'));

data/lib/less/js/lib/less/tree/detached-ruleset.js

@@ -0,0 +1,20 @@
+(function (tree) {
+
+tree.DetachedRuleset = function (ruleset, frames) {
+    this.ruleset = ruleset;
+    this.frames = frames;
+};
+tree.DetachedRuleset.prototype = {
+    type: "DetachedRuleset",
+    accept: function (visitor) {
+        this.ruleset = visitor.visit(this.ruleset);
+    },
+    eval: function (env) {
+        var frames = this.frames || env.frames.slice(0);
+        return new tree.DetachedRuleset(this.ruleset, frames);
+    },
+    callEval: function (env) {
+        return this.ruleset.eval(this.frames ? new(tree.evalEnv)(env, this.frames.concat(env.frames)) : env);
+    }
+};
+})(require('../tree'));

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

@@ -5,37 +5,109 @@
 //
 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;
+    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 = tree.fround(env, 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.isLength()) {
+                output.add(strValue);
+                return;
+            }
+
+            // Float values doesn't need a leading zero
+            if (value > 0 && value < 1) {
+                strValue = (strValue).substr(1);
+            }
+        }
+
+        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 + 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) {
+        /*jshint noempty:false */
+        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);
     },
 
-    // TODO: Perform unit conversion before comparing
     compare: function (other) {
         if (other instanceof tree.Dimension) {
-            if (other.value > this.value) {
+            var a, b,
+                aValue, bValue;
+            
+            if (this.unit.isEmpty() || other.unit.isEmpty()) {
+                a = this;
+                b = other;
+            } else {
+                a = this.unify();
+                b = other.unify();
+                if (a.unit.compare(b.unit) !== 0) {
+                    return -1;
+                }                
+            }
+            aValue = a.value;
+            bValue = b.value;
+
+            if (bValue > aValue) {
                 return -1;
-            } else if (other.value < this.value) {
+            } else if (bValue < aValue) {
                 return 1;
             } else {
                 return 0;
@@ -43,6 +115,209 @@ tree.Dimension.prototype = {
         } else {
             return -1;
         }
+    },
+
+    unify: function () {
+        return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
+    },
+
+    convertTo: function (conversions) {
+        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]);
+                }
+
+                return targetUnit;
+            }
+
+            return atomicUnit;
+        };
+
+        for (groupName in conversions) {
+            if (conversions.hasOwnProperty(groupName)) {
+                targetUnit = conversions[groupName];
+                group = tree.UnitConversions[groupName];
+
+                unit.map(applyUnit);
+            }
+        }
+
+        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,
+        'px': 0.0254 / 96,
+        '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);
+    },
+    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 () {
+      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;
+    },
+
+    isLength: function () {
+        return Boolean(this.toCSS().match(/px|em|%|in|cm|mm|pc|pt|ex/));
+    },
+
+    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, result = {}, mapUnit;
+
+        mapUnit = function (atomicUnit) {
+        /*jshint loopfunc:true */
+            if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
+                result[groupName] = atomicUnit;
+            }
+
+            return atomicUnit;
+        };
+
+        for (var groupName in tree.UnitConversions) {
+            if (tree.UnitConversions.hasOwnProperty(groupName)) {
+                group = tree.UnitConversions[groupName];
+
+                this.map(mapUnit);
+            }
+        }
+
+        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();
     }
 };
 

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

@@ -1,35 +1,69 @@
 (function (tree) {
 
-tree.Directive = function (name, value, features) {
-    this.name = name;
-
-    if (Array.isArray(value)) {
-        this.ruleset = new(tree.Ruleset)([], value);
-        this.ruleset.allowImports = true;
-    } else {
-        this.value = value;
+tree.Directive = function (name, value, rules, index, currentFileInfo, debugInfo) {
+    this.name  = name;
+    this.value = value;
+    if (rules) {
+        this.rules = rules;
+        this.rules.allowImports = true;
     }
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+    this.debugInfo = debugInfo;
 };
+
 tree.Directive.prototype = {
-    toCSS: function (ctx, env) {
-        if (this.ruleset) {
-            this.ruleset.root = true;
-            return this.name + (env.compress ? '{' : ' {\n  ') +
-                   this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
-                               (env.compress ? '}': '\n}\n');
+    type: "Directive",
+    accept: function (visitor) {
+        var value = this.value, rules = this.rules;
+        if (rules) {
+            rules = visitor.visit(rules);
+        }
+        if (value) {
+            value = visitor.visit(value);
+        }
+    },
+    genCSS: function (env, output) {
+        var value = this.value, rules = this.rules;
+        output.add(this.name, this.currentFileInfo, this.index);
+        if (value) {
+            output.add(' ');
+            value.genCSS(env, output);
+        }
+        if (rules) {
+            tree.outputRuleset(env, output, [rules]);
         } else {
-            return this.name + ' ' + this.value.toCSS() + ';\n';
+            output.add(';');
         }
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
-        env.frames.unshift(this);
-        this.ruleset = this.ruleset && this.ruleset.eval(env);
-        env.frames.shift();
-        return this;
+        var value = this.value, rules = this.rules;
+        if (value) {
+            value = value.eval(env);
+        }
+        if (rules) {
+            rules = rules.eval(env);
+            rules.root = true;
+        }
+        return new(tree.Directive)(this.name, value, rules,
+            this.index, this.currentFileInfo, this.debugInfo);
     },
-    variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) },
-    find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) },
-    rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) }
+    variable: function (name) { if (this.rules) return tree.Ruleset.prototype.variable.call(this.rules, name); },
+    find: function () { if (this.rules) return tree.Ruleset.prototype.find.apply(this.rules, arguments); },
+    rulesets: function () { if (this.rules) return tree.Ruleset.prototype.rulesets.apply(this.rules); },
+    markReferenced: function () {
+        var i, rules;
+        this.isReferenced = true;
+        if (this.rules) {
+            rules = this.rules.rules;
+            for (i = 0; i < rules.length; i++) {
+                if (rules[i].markReferenced) {
+                    rules[i].markReferenced();
+                }
+            }
+        }
+    }
 };
 
 })(require('../tree'));

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

@@ -1,6 +1,6 @@
 (function (tree) {
 
-tree.Element = function (combinator, value, index) {
+tree.Element = function (combinator, value, index, currentFileInfo) {
     this.combinator = combinator instanceof tree.Combinator ?
                       combinator : new(tree.Combinator)(combinator);
 
@@ -12,36 +12,97 @@ tree.Element = function (combinator, value, index) {
         this.value = "";
     }
     this.index = index;
+    this.currentFileInfo = currentFileInfo;
 };
-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) {
+        var value = this.value;
+        this.combinator = visitor.visit(this.combinator);
+        if (typeof value === "object") {
+            this.value = visitor.visit(value);
+        }
+    },
+    eval: function (env) {
+        return new(tree.Element)(this.combinator,
+                                 this.value.eval ? this.value.eval(env) : this.value,
+                                 this.index,
+                                 this.currentFileInfo);
+    },
+    genCSS: function (env, output) {
+        output.add(this.toCSS(env), this.currentFileInfo, 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) {
-    return this.combinator.toCSS(env || {}) + (this.value.toCSS ? this.value.toCSS(env) : this.value);
+
+tree.Attribute = function (key, op, value) {
+    this.key = key;
+    this.op = op;
+    this.value = value;
+};
+tree.Attribute.prototype = {
+    type: "Attribute",
+    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);
+    },
+    genCSS: function (env, output) {
+        output.add(this.toCSS(env));
+    },
+    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) {
     if (value === ' ') {
         this.value = ' ';
-    } else if (value === '& ') {
-        this.value = '& ';
     } else {
         this.value = value ? value.trim() : "";
     }
 };
-tree.Combinator.prototype.toCSS = function (env) {
-    return {
+tree.Combinator.prototype = {
+    type: "Combinator",
+    _outputMap: {
+        ''  : '',
+        ' ' : ' ',
+        ':' : ' :',
+        '+' : ' + ',
+        '~' : ' ~ ',
+        '>' : ' > ',
+        '|' : '|',
+        '^' : ' ^ ',
+        '^^' : ' ^^ '
+    },
+    _outputMapCompressed: {
         ''  : '',
         ' ' : ' ',
-        '&' : '',
-        '& ' : ' ',
         ':' : ' :',
-        '+' : env.compress ? '+' : ' + ',
-        '~' : env.compress ? '~' : ' ~ ',
-        '>' : env.compress ? '>' : ' > '
-    }[this.value];
+        '+' : '+',
+        '~' : '~',
+        '>' : '>',
+        '|' : '|',
+        '^' : '^',
+        '^^' : '^^'
+    },
+    genCSS: function (env, output) {
+        output.add((env.compress ? this._outputMapCompressed : this._outputMap)[this.value]);
+    },
+    toCSS: tree.toCSS
 };
 
 })(require('../tree'));