less-execjs 2.6.0.3

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

@@ -0,0 +1,28 @@
+var Node = require("./node");
+
+var Alpha = function (val) {
+    this.value = val;
+};
+Alpha.prototype = new Node();
+Alpha.prototype.type = "Alpha";
+
+Alpha.prototype.accept = function (visitor) {
+    this.value = visitor.visit(this.value);
+};
+Alpha.prototype.eval = function (context) {
+    if (this.value.eval) { return new Alpha(this.value.eval(context)); }
+    return this;
+};
+Alpha.prototype.genCSS = function (context, output) {
+    output.add("alpha(opacity=");
+
+    if (this.value.genCSS) {
+        this.value.genCSS(context, output);
+    } else {
+        output.add(this.value);
+    }
+
+    output.add(")");
+};
+
+module.exports = Alpha;

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

@@ -0,0 +1,26 @@
+var Node = require("./node");
+
+var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike, visibilityInfo) {
+    this.value = value;
+    this.index = index;
+    this.mapLines = mapLines;
+    this.currentFileInfo = currentFileInfo;
+    this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
+
+    this.copyVisibilityInfo(visibilityInfo);
+};
+Anonymous.prototype = new Node();
+Anonymous.prototype.type = "Anonymous";
+Anonymous.prototype.eval = function () {
+    return new Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines, this.rulesetLike, this.visibilityInfo());
+};
+Anonymous.prototype.compare = function (other) {
+    return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
+};
+Anonymous.prototype.isRulesetLike = function() {
+    return this.rulesetLike;
+};
+Anonymous.prototype.genCSS = function (context, output) {
+    output.add(this.value, this.currentFileInfo, this.index, this.mapLines);
+};
+module.exports = Anonymous;

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

@@ -0,0 +1,27 @@
+var Node = require("./node");
+
+var Assignment = function (key, val) {
+    this.key = key;
+    this.value = val;
+};
+
+Assignment.prototype = new Node();
+Assignment.prototype.type = "Assignment";
+Assignment.prototype.accept = function (visitor) {
+    this.value = visitor.visit(this.value);
+};
+Assignment.prototype.eval = function (context) {
+    if (this.value.eval) {
+        return new Assignment(this.key, this.value.eval(context));
+    }
+    return this;
+};
+Assignment.prototype.genCSS = function (context, output) {
+    output.add(this.key + '=');
+    if (this.value.genCSS) {
+        this.value.genCSS(context, output);
+    } else {
+        output.add(this.value);
+    }
+};
+module.exports = Assignment;

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

@@ -0,0 +1,27 @@
+var Node = require("./node");
+
+var Attribute = function (key, op, value) {
+    this.key = key;
+    this.op = op;
+    this.value = value;
+};
+Attribute.prototype = new Node();
+Attribute.prototype.type = "Attribute";
+Attribute.prototype.eval = function (context) {
+    return new Attribute(this.key.eval ? this.key.eval(context) : this.key,
+        this.op, (this.value && this.value.eval) ? this.value.eval(context) : this.value);
+};
+Attribute.prototype.genCSS = function (context, output) {
+    output.add(this.toCSS(context));
+};
+Attribute.prototype.toCSS = function (context) {
+    var value = this.key.toCSS ? this.key.toCSS(context) : this.key;
+
+    if (this.op) {
+        value += this.op;
+        value += (this.value.toCSS ? this.value.toCSS(context) : this.value);
+    }
+
+    return '[' + value + ']';
+};
+module.exports = Attribute;

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

@@ -0,0 +1,62 @@
+var Node = require("./node"),
+    FunctionCaller = require("../functions/function-caller");
+//
+// A function call node.
+//
+var Call = function (name, args, index, currentFileInfo) {
+    this.name = name;
+    this.args = args;
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+};
+Call.prototype = new Node();
+Call.prototype.type = "Call";
+Call.prototype.accept = function (visitor) {
+    if (this.args) {
+        this.args = visitor.visitArray(this.args);
+    }
+};
+//
+// When evaluating a function call,
+// we either find the function in the functionRegistry,
+// in which case we call it, passing the  evaluated arguments,
+// if this returns null or we cannot find the function, we
+// simply print it out as it appeared originally [2].
+//
+// The reason why we evaluate the arguments, is in the case where
+// we try to pass a variable to a function, like: `saturate(@color)`.
+// The function should receive the value, not the variable.
+//
+Call.prototype.eval = function (context) {
+    var args = this.args.map(function (a) { return a.eval(context); }),
+        result, funcCaller = new FunctionCaller(this.name, context, this.index, this.currentFileInfo);
+
+    if (funcCaller.isValid()) { // 1.
+        try {
+            result = funcCaller.call(args);
+            if (result != null) {
+                return result;
+            }
+        } catch (e) {
+            throw { type: e.type || "Runtime",
+                    message: "error evaluating function `" + this.name + "`" +
+                             (e.message ? ': ' + e.message : ''),
+                    index: this.index, filename: this.currentFileInfo.filename };
+        }
+    }
+
+    return new Call(this.name, args, this.index, this.currentFileInfo);
+};
+Call.prototype.genCSS = function (context, output) {
+    output.add(this.name + "(", this.currentFileInfo, this.index);
+
+    for (var i = 0; i < this.args.length; i++) {
+        this.args[i].genCSS(context, output);
+        if (i + 1 < this.args.length) {
+            output.add(", ");
+        }
+    }
+
+    output.add(")");
+};
+module.exports = Call;

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

@@ -0,0 +1,189 @@
+var Node = require("./node"),
+    colors = require("../data/colors");
+
+//
+// RGB Colors - #ff0014, #eee
+//
+var Color = function (rgb, a, originalForm) {
+    //
+    // The end goal here, is to parse the arguments
+    // into an integer triplet, such as `128, 255, 0`
+    //
+    // This facilitates operations and conversions.
+    //
+    if (Array.isArray(rgb)) {
+        this.rgb = rgb;
+    } else if (rgb.length == 6) {
+        this.rgb = rgb.match(/.{2}/g).map(function (c) {
+            return parseInt(c, 16);
+        });
+    } else {
+        this.rgb = rgb.split('').map(function (c) {
+            return parseInt(c + c, 16);
+        });
+    }
+    this.alpha = typeof a === 'number' ? a : 1;
+    if (typeof originalForm !== 'undefined') {
+        this.value = originalForm;
+    }
+};
+
+Color.prototype = new Node();
+Color.prototype.type = "Color";
+
+function clamp(v, max) {
+    return Math.min(Math.max(v, 0), max);
+}
+
+function toHex(v) {
+    return '#' + v.map(function (c) {
+        c = clamp(Math.round(c), 255);
+        return (c < 16 ? '0' : '') + c.toString(16);
+    }).join('');
+}
+
+Color.prototype.luma = function () {
+    var r = this.rgb[0] / 255,
+        g = this.rgb[1] / 255,
+        b = this.rgb[2] / 255;
+
+    r = (r <= 0.03928) ? r / 12.92 : Math.pow(((r + 0.055) / 1.055), 2.4);
+    g = (g <= 0.03928) ? g / 12.92 : Math.pow(((g + 0.055) / 1.055), 2.4);
+    b = (b <= 0.03928) ? b / 12.92 : Math.pow(((b + 0.055) / 1.055), 2.4);
+
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+Color.prototype.genCSS = function (context, output) {
+    output.add(this.toCSS(context));
+};
+Color.prototype.toCSS = function (context, doNotCompress) {
+    var compress = context && context.compress && !doNotCompress, color, alpha;
+
+    // `value` is set if this color was originally
+    // converted from a named color string so we need
+    // to respect this and try to output named color too.
+    if (this.value) {
+        return this.value;
+    }
+
+    // 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.
+    alpha = this.fround(context, this.alpha);
+    if (alpha < 1) {
+        return "rgba(" + this.rgb.map(function (c) {
+            return clamp(Math.round(c), 255);
+        }).concat(clamp(alpha, 1))
+            .join(',' + (compress ? '' : ' ')) + ")";
+    }
+
+    color = this.toRGB();
+
+    if (compress) {
+        var splitcolor = color.split('');
+
+        // Convert color to short format
+        if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
+            color = '#' + splitcolor[1] + splitcolor[3] + splitcolor[5];
+        }
+    }
+
+    return color;
+};
+
+//
+// Operations have to be done per-channel, if not,
+// channels will spill onto each other. Once we have
+// our result, in the form of an integer triplet,
+// we create a new Color node to hold the result.
+//
+Color.prototype.operate = function (context, op, other) {
+    var rgb = [];
+    var alpha = this.alpha * (1 - other.alpha) + other.alpha;
+    for (var c = 0; c < 3; c++) {
+        rgb[c] = this._operate(context, op, this.rgb[c], other.rgb[c]);
+    }
+    return new Color(rgb, alpha);
+};
+Color.prototype.toRGB = function () {
+    return toHex(this.rgb);
+};
+Color.prototype.toHSL = 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, l = (max + min) / 2, d = max - min;
+
+    if (max === min) {
+        h = s = 0;
+    } else {
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+        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, l: l, a: a };
+};
+//Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+Color.prototype.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 };
+};
+Color.prototype.toARGB = function () {
+    return toHex([this.alpha * 255].concat(this.rgb));
+};
+Color.prototype.compare = function (x) {
+    return (x.rgb &&
+        x.rgb[0] === this.rgb[0] &&
+        x.rgb[1] === this.rgb[1] &&
+        x.rgb[2] === this.rgb[2] &&
+        x.alpha  === this.alpha) ? 0 : undefined;
+};
+
+Color.fromKeyword = function(keyword) {
+    var c, key = keyword.toLowerCase();
+    if (colors.hasOwnProperty(key)) {
+        c = new Color(colors[key].slice(1));
+    }
+    else if (key === "transparent") {
+        c = new Color([0, 0, 0], 0);
+    }
+
+    if (c) {
+        c.value = keyword;
+        return c;
+    }
+};
+module.exports = Color;

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

@@ -0,0 +1,23 @@
+var Node = require("./node");
+
+var Combinator = function (value) {
+    if (value === ' ') {
+        this.value = ' ';
+        this.emptyOrWhitespace = true;
+    } else {
+        this.value = value ? value.trim() : "";
+        this.emptyOrWhitespace = this.value === "";
+    }
+};
+Combinator.prototype = new Node();
+Combinator.prototype.type = "Combinator";
+var _noSpaceCombinators = {
+    '': true,
+    ' ': true,
+    '|': true
+};
+Combinator.prototype.genCSS = function (context, output) {
+    var spaceOrEmpty = (context.compress || _noSpaceCombinators[this.value]) ? '' : ' ';
+    output.add(spaceOrEmpty + this.value + spaceOrEmpty);
+};
+module.exports = Combinator;

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

@@ -0,0 +1,21 @@
+var Node = require("./node"),
+    getDebugInfo = require("./debug-info");
+
+var Comment = function (value, isLineComment, index, currentFileInfo) {
+    this.value = value;
+    this.isLineComment = isLineComment;
+    this.currentFileInfo = currentFileInfo;
+};
+Comment.prototype = new Node();
+Comment.prototype.type = "Comment";
+Comment.prototype.genCSS = function (context, output) {
+    if (this.debugInfo) {
+        output.add(getDebugInfo(context, this), this.currentFileInfo, this.index);
+    }
+    output.add(this.value);
+};
+Comment.prototype.isSilent = function(context) {
+    var isCompressed = context.compress && this.value[2] !== "!";
+    return this.isLineComment || isCompressed;
+};
+module.exports = Comment;

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

@@ -0,0 +1,37 @@
+var Node = require("./node");
+
+var Condition = function (op, l, r, i, negate) {
+    this.op = op.trim();
+    this.lvalue = l;
+    this.rvalue = r;
+    this.index = i;
+    this.negate = negate;
+};
+Condition.prototype = new Node();
+Condition.prototype.type = "Condition";
+Condition.prototype.accept = function (visitor) {
+    this.lvalue = visitor.visit(this.lvalue);
+    this.rvalue = visitor.visit(this.rvalue);
+};
+Condition.prototype.eval = function (context) {
+    var result = (function (op, a, b) {
+        switch (op) {
+            case 'and': return a && b;
+            case 'or':  return a || b;
+            default:
+                switch (Node.compare(a, b)) {
+                    case -1:
+                        return op === '<' || op === '=<' || op === '<=';
+                    case 0:
+                        return op === '=' || op === '>=' || op === '=<' || op === '<=';
+                    case 1:
+                        return op === '>' || op === '>=';
+                    default:
+                        return false;
+                }
+        }
+    })(this.op, this.lvalue.eval(context), this.rvalue.eval(context));
+
+    return this.negate ? !result : result;
+};
+module.exports = Condition;