less-execjs 2.6.0.3

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

@@ -0,0 +1,182 @@
+var Node = require("./node"),
+    Selector = require("./selector"),
+    MixinDefinition = require("./mixin-definition"),
+    defaultFunc = require("../functions/default");
+
+var MixinCall = function (elements, args, index, currentFileInfo, important) {
+    this.selector = new Selector(elements);
+    this.arguments = args || [];
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+    this.important = important;
+};
+MixinCall.prototype = new Node();
+MixinCall.prototype.type = "MixinCall";
+MixinCall.prototype.accept = function (visitor) {
+    if (this.selector) {
+        this.selector = visitor.visit(this.selector);
+    }
+    if (this.arguments.length) {
+        this.arguments = visitor.visitArray(this.arguments);
+    }
+};
+MixinCall.prototype.eval = function (context) {
+    var mixins, mixin, mixinPath, args = [], arg, argValue,
+        rules = [], match = false, i, m, f, isRecursive, isOneFound,
+        candidates = [], candidate, conditionResult = [], defaultResult, defFalseEitherCase = -1,
+        defNone = 0, defTrue = 1, defFalse = 2, count, originalRuleset, noArgumentsFilter;
+
+    function calcDefGroup(mixin, mixinPath) {
+        var f, p, namespace;
+
+        for (f = 0; f < 2; f++) {
+            conditionResult[f] = true;
+            defaultFunc.value(f);
+            for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
+                namespace = mixinPath[p];
+                if (namespace.matchCondition) {
+                    conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
+                }
+            }
+            if (mixin.matchCondition) {
+                conditionResult[f] = conditionResult[f] && mixin.matchCondition(args, context);
+            }
+        }
+        if (conditionResult[0] || conditionResult[1]) {
+            if (conditionResult[0] != conditionResult[1]) {
+                return conditionResult[1] ?
+                    defTrue : defFalse;
+            }
+
+            return defNone;
+        }
+        return defFalseEitherCase;
+    }
+
+    for (i = 0; i < this.arguments.length; i++) {
+        arg = this.arguments[i];
+        argValue = arg.value.eval(context);
+        if (arg.expand && Array.isArray(argValue.value)) {
+            argValue = argValue.value;
+            for (m = 0; m < argValue.length; m++) {
+                args.push({value: argValue[m]});
+            }
+        } else {
+            args.push({name: arg.name, value: argValue});
+        }
+    }
+
+    noArgumentsFilter = function(rule) {return rule.matchArgs(null, context);};
+
+    for (i = 0; i < context.frames.length; i++) {
+        if ((mixins = context.frames[i].find(this.selector, null, noArgumentsFilter)).length > 0) {
+            isOneFound = true;
+
+            // To make `default()` function independent of definition order we have two "subpasses" here.
+            // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
+            // and build candidate list with corresponding flags. Then, when we know all possible matches,
+            // we make a final decision.
+
+            for (m = 0; m < mixins.length; m++) {
+                mixin = mixins[m].rule;
+                mixinPath = mixins[m].path;
+                isRecursive = false;
+                for (f = 0; f < context.frames.length; f++) {
+                    if ((!(mixin instanceof MixinDefinition)) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
+                        isRecursive = true;
+                        break;
+                    }
+                }
+                if (isRecursive) {
+                    continue;
+                }
+
+                if (mixin.matchArgs(args, context)) {
+                    candidate = {mixin: mixin, group: calcDefGroup(mixin, mixinPath)};
+
+                    if (candidate.group !== defFalseEitherCase) {
+                        candidates.push(candidate);
+                    }
+
+                    match = true;
+                }
+            }
+
+            defaultFunc.reset();
+
+            count = [0, 0, 0];
+            for (m = 0; m < candidates.length; m++) {
+                count[candidates[m].group]++;
+            }
+
+            if (count[defNone] > 0) {
+                defaultResult = defFalse;
+            } else {
+                defaultResult = defTrue;
+                if ((count[defTrue] + count[defFalse]) > 1) {
+                    throw { type: 'Runtime',
+                        message: 'Ambiguous use of `default()` found when matching for `' + this.format(args) + '`',
+                        index: this.index, filename: this.currentFileInfo.filename };
+                }
+            }
+
+            for (m = 0; m < candidates.length; m++) {
+                candidate = candidates[m].group;
+                if ((candidate === defNone) || (candidate === defaultResult)) {
+                    try {
+                        mixin = candidates[m].mixin;
+                        if (!(mixin instanceof MixinDefinition)) {
+                            originalRuleset = mixin.originalRuleset || mixin;
+                            mixin = new MixinDefinition("", [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
+                            mixin.originalRuleset = originalRuleset;
+                        }
+                        var newRules = mixin.evalCall(context, args, this.important).rules;
+                        this._setVisibilityToReplacement(newRules);
+                        Array.prototype.push.apply(rules, newRules);
+                    } catch (e) {
+                        throw { message: e.message, index: this.index, filename: this.currentFileInfo.filename, stack: e.stack };
+                    }
+                }
+            }
+
+            if (match) {
+                return rules;
+            }
+        }
+    }
+    if (isOneFound) {
+        throw { type:    'Runtime',
+            message: 'No matching definition was found for `' + this.format(args) + '`',
+            index:   this.index, filename: this.currentFileInfo.filename };
+    } else {
+        throw { type:    'Name',
+            message: this.selector.toCSS().trim() + " is undefined",
+            index:   this.index, filename: this.currentFileInfo.filename };
+    }
+};
+
+MixinCall.prototype._setVisibilityToReplacement = function (replacement) {
+    var i, rule;
+    if (this.blocksVisibility()) {
+        for (i = 0; i < replacement.length; i++) {
+            rule = replacement[i];
+            rule.addVisibilityBlock();
+        }
+    }
+};
+MixinCall.prototype.format = function (args) {
+    return this.selector.toCSS().trim() + '(' +
+        (args ? args.map(function (a) {
+            var argValue = "";
+            if (a.name) {
+                argValue += a.name + ":";
+            }
+            if (a.value.toCSS) {
+                argValue += a.value.toCSS();
+            } else {
+                argValue += "???";
+            }
+            return argValue;
+        }).join(', ') : "") + ")";
+};
+module.exports = MixinCall;

data/lib/less/js/less/lib/less/tree/mixin-definition.js

@@ -0,0 +1,200 @@
+var Selector = require("./selector"),
+    Element = require("./element"),
+    Ruleset = require("./ruleset"),
+    Rule = require("./rule"),
+    Expression = require("./expression"),
+    contexts = require("../contexts");
+
+var Definition = function (name, params, rules, condition, variadic, frames, visibilityInfo) {
+    this.name = name;
+    this.selectors = [new Selector([new Element(null, name, this.index, this.currentFileInfo)])];
+    this.params = params;
+    this.condition = condition;
+    this.variadic = variadic;
+    this.arity = params.length;
+    this.rules = rules;
+    this._lookups = {};
+    var optionalParameters = [];
+    this.required = params.reduce(function (count, p) {
+        if (!p.name || (p.name && !p.value)) {
+            return count + 1;
+        }
+        else {
+            optionalParameters.push(p.name);
+            return count;
+        }
+    }, 0);
+    this.optionalParameters = optionalParameters;
+    this.frames = frames;
+    this.copyVisibilityInfo(visibilityInfo);
+};
+Definition.prototype = new Ruleset();
+Definition.prototype.type = "MixinDefinition";
+Definition.prototype.evalFirst = true;
+Definition.prototype.accept = function (visitor) {
+    if (this.params && this.params.length) {
+        this.params = visitor.visitArray(this.params);
+    }
+    this.rules = visitor.visitArray(this.rules);
+    if (this.condition) {
+        this.condition = visitor.visit(this.condition);
+    }
+};
+Definition.prototype.evalParams = function (context, mixinEnv, args, evaldArguments) {
+    /*jshint boss:true */
+    var frame = new Ruleset(null, null),
+        varargs, arg,
+        params = this.params.slice(0),
+        i, j, val, name, isNamedFound, argIndex, argsLength = 0;
+
+    if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
+        frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
+    }
+    mixinEnv = new contexts.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
+
+    if (args) {
+        args = args.slice(0);
+        argsLength = args.length;
+
+        for (i = 0; i < argsLength; i++) {
+            arg = args[i];
+            if (name = (arg && arg.name)) {
+                isNamedFound = false;
+                for (j = 0; j < params.length; j++) {
+                    if (!evaldArguments[j] && name === params[j].name) {
+                        evaldArguments[j] = arg.value.eval(context);
+                        frame.prependRule(new Rule(name, arg.value.eval(context)));
+                        isNamedFound = true;
+                        break;
+                    }
+                }
+                if (isNamedFound) {
+                    args.splice(i, 1);
+                    i--;
+                    continue;
+                } else {
+                    throw { type: 'Runtime', message: "Named argument for " + this.name +
+                        ' ' + args[i].name + ' not found' };
+                }
+            }
+        }
+    }
+    argIndex = 0;
+    for (i = 0; i < params.length; i++) {
+        if (evaldArguments[i]) { continue; }
+
+        arg = args && args[argIndex];
+
+        if (name = params[i].name) {
+            if (params[i].variadic) {
+                varargs = [];
+                for (j = argIndex; j < argsLength; j++) {
+                    varargs.push(args[j].value.eval(context));
+                }
+                frame.prependRule(new Rule(name, new Expression(varargs).eval(context)));
+            } else {
+                val = arg && arg.value;
+                if (val) {
+                    val = val.eval(context);
+                } else if (params[i].value) {
+                    val = params[i].value.eval(mixinEnv);
+                    frame.resetCache();
+                } else {
+                    throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
+                        ' (' + argsLength + ' for ' + this.arity + ')' };
+                }
+
+                frame.prependRule(new Rule(name, val));
+                evaldArguments[i] = val;
+            }
+        }
+
+        if (params[i].variadic && args) {
+            for (j = argIndex; j < argsLength; j++) {
+                evaldArguments[j] = args[j].value.eval(context);
+            }
+        }
+        argIndex++;
+    }
+
+    return frame;
+};
+Definition.prototype.makeImportant = function() {
+    var rules = !this.rules ? this.rules : this.rules.map(function (r) {
+        if (r.makeImportant) {
+            return r.makeImportant(true);
+        } else {
+            return r;
+        }
+    });
+    var result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
+    return result;
+};
+Definition.prototype.eval = function (context) {
+    return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || context.frames.slice(0));
+};
+Definition.prototype.evalCall = function (context, args, important) {
+    var _arguments = [],
+        mixinFrames = this.frames ? this.frames.concat(context.frames) : context.frames,
+        frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments),
+        rules, ruleset;
+
+    frame.prependRule(new Rule('@arguments', new Expression(_arguments).eval(context)));
+
+    rules = this.rules.slice(0);
+
+    ruleset = new Ruleset(null, rules);
+    ruleset.originalRuleset = this;
+    ruleset = ruleset.eval(new contexts.Eval(context, [this, frame].concat(mixinFrames)));
+    if (important) {
+        ruleset = ruleset.makeImportant();
+    }
+    return ruleset;
+};
+Definition.prototype.matchCondition = function (args, context) {
+    if (this.condition && !this.condition.eval(
+        new contexts.Eval(context,
+            [this.evalParams(context, /* the parameter variables*/
+                new contexts.Eval(context, this.frames ? this.frames.concat(context.frames) : context.frames), args, [])]
+            .concat(this.frames || []) // the parent namespace/mixin frames
+            .concat(context.frames)))) { // the current environment frames
+        return false;
+    }
+    return true;
+};
+Definition.prototype.matchArgs = function (args, context) {
+    var allArgsCnt = (args && args.length) || 0, len, optionalParameters = this.optionalParameters;
+    var requiredArgsCnt = !args ? 0 : args.reduce(function (count, p) {
+        if (optionalParameters.indexOf(p.name) < 0) {
+            return count + 1;
+        } else {
+            return count;
+        }
+    }, 0);
+
+    if (! this.variadic) {
+        if (requiredArgsCnt < this.required) {
+            return false;
+        }
+        if (allArgsCnt > this.params.length) {
+            return false;
+        }
+    } else {
+        if (requiredArgsCnt < (this.required - 1)) {
+            return false;
+        }
+    }
+
+    // check patterns
+    len = Math.min(requiredArgsCnt, this.arity);
+
+    for (var i = 0; i < len; i++) {
+        if (!this.params[i].name && !this.params[i].variadic) {
+            if (args[i].value.eval(context).toCSS() != this.params[i].value.eval(context).toCSS()) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+module.exports = Definition;

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

@@ -0,0 +1,20 @@
+var Node = require("./node"),
+    Operation = require("./operation"),
+    Dimension = require("./dimension");
+
+var Negative = function (node) {
+    this.value = node;
+};
+Negative.prototype = new Node();
+Negative.prototype.type = "Negative";
+Negative.prototype.genCSS = function (context, output) {
+    output.add('-');
+    this.value.genCSS(context, output);
+};
+Negative.prototype.eval = function (context) {
+    if (context.isMathOn()) {
+        return (new Operation('*', [new Dimension(-1), this.value])).eval(context);
+    }
+    return new Negative(this.value.eval(context));
+};
+module.exports = Negative;

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

@@ -0,0 +1,123 @@
+var Node = function() {
+};
+Node.prototype.toCSS = function (context) {
+    var strs = [];
+    this.genCSS(context, {
+        add: function(chunk, fileInfo, index) {
+            strs.push(chunk);
+        },
+        isEmpty: function () {
+            return strs.length === 0;
+        }
+    });
+    return strs.join('');
+};
+Node.prototype.genCSS = function (context, output) {
+    output.add(this.value);
+};
+Node.prototype.accept = function (visitor) {
+    this.value = visitor.visit(this.value);
+};
+Node.prototype.eval = function () { return this; };
+Node.prototype._operate = function (context, op, a, b) {
+    switch (op) {
+        case '+': return a + b;
+        case '-': return a - b;
+        case '*': return a * b;
+        case '/': return a / b;
+    }
+};
+Node.prototype.fround = function(context, value) {
+    var precision = context && context.numPrecision;
+    //add "epsilon" to ensure numbers like 1.000000005 (represented as 1.000000004999....) are properly rounded...
+    return (precision == null) ? value : Number((value + 2e-16).toFixed(precision));
+};
+Node.compare = function (a, b) {
+    /* returns:
+     -1: a < b
+     0: a = b
+     1: a > b
+     and *any* other value for a != b (e.g. undefined, NaN, -2 etc.) */
+
+    if ((a.compare) &&
+        // for "symmetric results" force toCSS-based comparison
+        // of Quoted or Anonymous if either value is one of those
+        !(b.type === "Quoted" || b.type === "Anonymous")) {
+        return a.compare(b);
+    } else if (b.compare) {
+        return -b.compare(a);
+    } else if (a.type !== b.type) {
+        return undefined;
+    }
+
+    a = a.value;
+    b = b.value;
+    if (!Array.isArray(a)) {
+        return a === b ? 0 : undefined;
+    }
+    if (a.length !== b.length) {
+        return undefined;
+    }
+    for (var i = 0; i < a.length; i++) {
+        if (Node.compare(a[i], b[i]) !== 0) {
+            return undefined;
+        }
+    }
+    return 0;
+};
+
+Node.numericCompare = function (a, b) {
+    return a  <  b ? -1
+        : a === b ?  0
+        : a  >  b ?  1 : undefined;
+};
+// Returns true if this node represents root of ast imported by reference
+Node.prototype.blocksVisibility = function () {
+    if (this.visibilityBlocks == null) {
+        this.visibilityBlocks = 0;
+    }
+    return this.visibilityBlocks !== 0;
+};
+Node.prototype.addVisibilityBlock = function () {
+    if (this.visibilityBlocks == null) {
+        this.visibilityBlocks = 0;
+    }
+    this.visibilityBlocks = this.visibilityBlocks + 1;
+};
+Node.prototype.removeVisibilityBlock = function () {
+    if (this.visibilityBlocks == null) {
+        this.visibilityBlocks = 0;
+    }
+    this.visibilityBlocks = this.visibilityBlocks - 1;
+};
+//Turns on node visibility - if called node will be shown in output regardless
+//of whether it comes from import by reference or not
+Node.prototype.ensureVisibility = function () {
+    this.nodeVisible = true;
+};
+//Turns off node visibility - if called node will NOT be shown in output regardless
+//of whether it comes from import by reference or not
+Node.prototype.ensureInvisibility = function () {
+    this.nodeVisible = false;
+};
+// return values:
+// false - the node must not be visible
+// true - the node must be visible
+// undefined or null - the node has the same visibility as its parent
+Node.prototype.isVisible = function () {
+    return this.nodeVisible;
+};
+Node.prototype.visibilityInfo = function() {
+    return {
+        visibilityBlocks: this.visibilityBlocks,
+        nodeVisible: this.nodeVisible
+    };
+};
+Node.prototype.copyVisibilityInfo = function(info) {
+    if (!info) {
+        return;
+    }
+    this.visibilityBlocks = info.visibilityBlocks;
+    this.nodeVisible = info.nodeVisible;
+};
+module.exports = Node;