less-execjs 2.6.0.3

data/lib/less/js/less/lib/less/tree/debug-info.js

@@ -0,0 +1,38 @@
+var debugInfo = function(context, ctx, lineSeparator) {
+    var result = "";
+    if (context.dumpLineNumbers && !context.compress) {
+        switch(context.dumpLineNumbers) {
+            case 'comments':
+                result = debugInfo.asComment(ctx);
+                break;
+            case 'mediaquery':
+                result = debugInfo.asMediaQuery(ctx);
+                break;
+            case 'all':
+                result = debugInfo.asComment(ctx) + (lineSeparator || "") + debugInfo.asMediaQuery(ctx);
+                break;
+        }
+    }
+    return result;
+};
+
+debugInfo.asComment = function(ctx) {
+    return '/* line ' + ctx.debugInfo.lineNumber + ', ' + ctx.debugInfo.fileName + ' */\n';
+};
+
+debugInfo.asMediaQuery = function(ctx) {
+    var filenameWithProtocol = ctx.debugInfo.fileName;
+    if (!/^[a-z]+:\/\//i.test(filenameWithProtocol)) {
+        filenameWithProtocol = 'file://' + filenameWithProtocol;
+    }
+    return '@media -sass-debug-info{filename{font-family:' +
+        filenameWithProtocol.replace(/([.:\/\\])/g, function (a) {
+            if (a == '\\') {
+                a = '\/';
+            }
+            return '\\' + a;
+        }) +
+        '}line{font-family:\\00003' + ctx.debugInfo.lineNumber + '}}\n';
+};
+
+module.exports = debugInfo;

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

@@ -0,0 +1,21 @@
+var Node = require("./node"),
+    contexts = require("../contexts");
+
+var DetachedRuleset = function (ruleset, frames) {
+    this.ruleset = ruleset;
+    this.frames = frames;
+};
+DetachedRuleset.prototype = new Node();
+DetachedRuleset.prototype.type = "DetachedRuleset";
+DetachedRuleset.prototype.evalFirst = true;
+DetachedRuleset.prototype.accept = function (visitor) {
+    this.ruleset = visitor.visit(this.ruleset);
+};
+DetachedRuleset.prototype.eval = function (context) {
+    var frames = this.frames || context.frames.slice(0);
+    return new DetachedRuleset(this.ruleset, frames);
+};
+DetachedRuleset.prototype.callEval = function (context) {
+    return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
+};
+module.exports = DetachedRuleset;

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

@@ -0,0 +1,157 @@
+var Node = require("./node"),
+    unitConversions = require("../data/unit-conversions"),
+    Unit = require("./unit"),
+    Color = require("./color");
+
+//
+// A number with a unit
+//
+var Dimension = function (value, unit) {
+    this.value = parseFloat(value);
+    this.unit = (unit && unit instanceof Unit) ? unit :
+      new Unit(unit ? [unit] : undefined);
+};
+
+Dimension.prototype = new Node();
+Dimension.prototype.type = "Dimension";
+Dimension.prototype.accept = function (visitor) {
+    this.unit = visitor.visit(this.unit);
+};
+Dimension.prototype.eval = function (context) {
+    return this;
+};
+Dimension.prototype.toColor = function () {
+    return new Color([this.value, this.value, this.value]);
+};
+Dimension.prototype.genCSS = function (context, output) {
+    if ((context && context.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.fround(context, 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 (context && context.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(context, output);
+};
+
+// In an operation between two Dimensions,
+// we default to the first Dimension's unit,
+// so `1px + 2` will yield `3px`.
+Dimension.prototype.operate = function (context, op, other) {
+    /*jshint noempty:false */
+    var value = this._operate(context, op, this.value, other.value),
+        unit = this.unit.clone();
+
+    if (op === '+' || op === '-') {
+        if (unit.numerator.length === 0 && unit.denominator.length === 0) {
+            unit = other.unit.clone();
+            if (this.unit.backupUnit) {
+                unit.backupUnit = this.unit.backupUnit;
+            }
+        } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
+            // do nothing
+        } else {
+            other = other.convertTo(this.unit.usedUnits());
+
+            if (context.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 = this._operate(context, 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 Dimension(value, unit);
+};
+Dimension.prototype.compare = function (other) {
+    var a, b;
+
+    if (!(other instanceof Dimension)) {
+        return undefined;
+    }
+
+    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 undefined;
+        }
+    }
+
+    return Node.numericCompare(a.value, b.value);
+};
+Dimension.prototype.unify = function () {
+    return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
+};
+Dimension.prototype.convertTo = function (conversions) {
+    var value = this.value, unit = this.unit.clone(),
+        i, groupName, group, targetUnit, derivedConversions = {}, applyUnit;
+
+    if (typeof conversions === 'string') {
+        for (i in unitConversions) {
+            if (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 = unitConversions[groupName];
+
+            unit.map(applyUnit);
+        }
+    }
+
+    unit.cancel();
+
+    return new Dimension(value, unit);
+};
+module.exports = Dimension;

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

@@ -0,0 +1,133 @@
+var Node = require("./node"),
+    Selector = require("./selector"),
+    Ruleset = require("./ruleset");
+
+var Directive = function (name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
+    var i;
+
+    this.name  = name;
+    this.value = value;
+    if (rules) {
+        if (Array.isArray(rules)) {
+            this.rules = rules;
+        } else {
+            this.rules = [rules];
+            this.rules[0].selectors = (new Selector([], null, null, this.index, currentFileInfo)).createEmptySelectors();
+        }
+        for (i = 0; i < this.rules.length; i++) {
+            this.rules[i].allowImports = true;
+        }
+    }
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+    this.debugInfo = debugInfo;
+    this.isRooted = isRooted || false;
+    this.copyVisibilityInfo(visibilityInfo);
+};
+
+Directive.prototype = new Node();
+Directive.prototype.type = "Directive";
+Directive.prototype.accept = function (visitor) {
+    var value = this.value, rules = this.rules;
+    if (rules) {
+        this.rules = visitor.visitArray(rules);
+    }
+    if (value) {
+        this.value = visitor.visit(value);
+    }
+};
+Directive.prototype.isRulesetLike = function() {
+    return this.rules || !this.isCharset();
+};
+Directive.prototype.isCharset = function() {
+    return "@charset" === this.name;
+};
+Directive.prototype.genCSS = function (context, output) {
+    var value = this.value, rules = this.rules;
+    output.add(this.name, this.currentFileInfo, this.index);
+    if (value) {
+        output.add(' ');
+        value.genCSS(context, output);
+    }
+    if (rules) {
+        this.outputRuleset(context, output, rules);
+    } else {
+        output.add(';');
+    }
+};
+Directive.prototype.eval = function (context) {
+    var mediaPathBackup, mediaBlocksBackup, value = this.value, rules = this.rules;
+
+    //media stored inside other directive should not bubble over it
+    //backpup media bubbling information
+    mediaPathBackup = context.mediaPath;
+    mediaBlocksBackup = context.mediaBlocks;
+    //deleted media bubbling information
+    context.mediaPath = [];
+    context.mediaBlocks = [];
+
+    if (value) {
+        value = value.eval(context);
+    }
+    if (rules) {
+        // assuming that there is only one rule at this point - that is how parser constructs the rule
+        rules = [rules[0].eval(context)];
+        rules[0].root = true;
+    }
+    //restore media bubbling information
+    context.mediaPath = mediaPathBackup;
+    context.mediaBlocks = mediaBlocksBackup;
+
+    return new Directive(this.name, value, rules,
+        this.index, this.currentFileInfo, this.debugInfo, this.isRooted, this.visibilityInfo());
+};
+Directive.prototype.variable = function (name) {
+    if (this.rules) {
+        // assuming that there is only one rule at this point - that is how parser constructs the rule
+        return Ruleset.prototype.variable.call(this.rules[0], name);
+    }
+};
+Directive.prototype.find = function () {
+    if (this.rules) {
+        // assuming that there is only one rule at this point - that is how parser constructs the rule
+        return Ruleset.prototype.find.apply(this.rules[0], arguments);
+    }
+};
+Directive.prototype.rulesets = function () {
+    if (this.rules) {
+        // assuming that there is only one rule at this point - that is how parser constructs the rule
+        return Ruleset.prototype.rulesets.apply(this.rules[0]);
+    }
+};
+Directive.prototype.outputRuleset = function (context, output, rules) {
+    var ruleCnt = rules.length, i;
+    context.tabLevel = (context.tabLevel | 0) + 1;
+
+    // Compressed
+    if (context.compress) {
+        output.add('{');
+        for (i = 0; i < ruleCnt; i++) {
+            rules[i].genCSS(context, output);
+        }
+        output.add('}');
+        context.tabLevel--;
+        return;
+    }
+
+    // Non-compressed
+    var tabSetStr = '\n' + Array(context.tabLevel).join("  "), tabRuleStr = tabSetStr + "  ";
+    if (!ruleCnt) {
+        output.add(" {" + tabSetStr + '}');
+    } else {
+        output.add(" {" + tabRuleStr);
+        rules[0].genCSS(context, output);
+        for (i = 1; i < ruleCnt; i++) {
+            output.add(tabRuleStr);
+            rules[i].genCSS(context, output);
+        }
+        output.add(tabSetStr + '}');
+    }
+
+    context.tabLevel--;
+};
+module.exports = Directive;

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

@@ -0,0 +1,60 @@
+var Node = require("./node"),
+    Paren = require("./paren"),
+    Combinator = require("./combinator");
+
+var Element = function (combinator, value, index, currentFileInfo, info) {
+    this.combinator = combinator instanceof Combinator ?
+                      combinator : new Combinator(combinator);
+
+    if (typeof value === 'string') {
+        this.value = value.trim();
+    } else if (value) {
+        this.value = value;
+    } else {
+        this.value = "";
+    }
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+    this.copyVisibilityInfo(info);
+};
+Element.prototype = new Node();
+Element.prototype.type = "Element";
+Element.prototype.accept = function (visitor) {
+    var value = this.value;
+    this.combinator = visitor.visit(this.combinator);
+    if (typeof value === "object") {
+        this.value = visitor.visit(value);
+    }
+};
+Element.prototype.eval = function (context) {
+    return new Element(this.combinator,
+                             this.value.eval ? this.value.eval(context) : this.value,
+                             this.index,
+                             this.currentFileInfo, this.visibilityInfo());
+};
+Element.prototype.clone = function () {
+    return new Element(this.combinator,
+        this.value,
+        this.index,
+        this.currentFileInfo, this.visibilityInfo());
+};
+Element.prototype.genCSS = function (context, output) {
+    output.add(this.toCSS(context), this.currentFileInfo, this.index);
+};
+Element.prototype.toCSS = function (context) {
+    context = context || {};
+    var value = this.value, firstSelector = context.firstSelector;
+    if (value instanceof Paren) {
+        // selector in parens should not be affected by outer selector
+        // flags (breaks only interpolated selectors - see #1973)
+        context.firstSelector = true;
+    }
+    value = value.toCSS ? value.toCSS(context) : value;
+    context.firstSelector = firstSelector;
+    if (value === '' && this.combinator.value.charAt(0) === '&') {
+        return '';
+    } else {
+        return this.combinator.toCSS(context) + value;
+    }
+};
+module.exports = Element;

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

@@ -0,0 +1,56 @@
+var Node = require("./node"),
+    Paren = require("./paren"),
+    Comment = require("./comment");
+
+var Expression = function (value) {
+    this.value = value;
+    if (!value) {
+        throw new Error("Expression requires an array parameter");
+    }
+};
+Expression.prototype = new Node();
+Expression.prototype.type = "Expression";
+Expression.prototype.accept = function (visitor) {
+    this.value = visitor.visitArray(this.value);
+};
+Expression.prototype.eval = function (context) {
+    var returnValue,
+        inParenthesis = this.parens && !this.parensInOp,
+        doubleParen = false;
+    if (inParenthesis) {
+        context.inParenthesis();
+    }
+    if (this.value.length > 1) {
+        returnValue = new Expression(this.value.map(function (e) {
+            return e.eval(context);
+        }));
+    } else if (this.value.length === 1) {
+        if (this.value[0].parens && !this.value[0].parensInOp) {
+            doubleParen = true;
+        }
+        returnValue = this.value[0].eval(context);
+    } else {
+        returnValue = this;
+    }
+    if (inParenthesis) {
+        context.outOfParenthesis();
+    }
+    if (this.parens && this.parensInOp && !(context.isMathOn()) && !doubleParen) {
+        returnValue = new Paren(returnValue);
+    }
+    return returnValue;
+};
+Expression.prototype.genCSS = function (context, output) {
+    for (var i = 0; i < this.value.length; i++) {
+        this.value[i].genCSS(context, output);
+        if (i + 1 < this.value.length) {
+            output.add(" ");
+        }
+    }
+};
+Expression.prototype.throwAwayComments = function () {
+    this.value = this.value.filter(function(v) {
+        return !(v instanceof Comment);
+    });
+};
+module.exports = Expression;