less-execjs 2.6.0.3

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

@@ -0,0 +1,56 @@
+var Node = require("./node"),
+    Selector = require("./selector");
+
+var Extend = function Extend(selector, option, index, currentFileInfo, visibilityInfo) {
+    this.selector = selector;
+    this.option = option;
+    this.index = index;
+    this.object_id = Extend.next_id++;
+    this.parent_ids = [this.object_id];
+    this.currentFileInfo = currentFileInfo || {};
+    this.copyVisibilityInfo(visibilityInfo);
+
+    switch(option) {
+        case "all":
+            this.allowBefore = true;
+            this.allowAfter = true;
+            break;
+        default:
+            this.allowBefore = false;
+            this.allowAfter = false;
+            break;
+    }
+};
+Extend.next_id = 0;
+
+Extend.prototype = new Node();
+Extend.prototype.type = "Extend";
+Extend.prototype.accept = function (visitor) {
+    this.selector = visitor.visit(this.selector);
+};
+Extend.prototype.eval = function (context) {
+    return new Extend(this.selector.eval(context), this.option, this.index, this.currentFileInfo, this.visibilityInfo());
+};
+Extend.prototype.clone = function (context) {
+    return new Extend(this.selector, this.option, this.index, this.currentFileInfo, this.visibilityInfo());
+};
+//it concatenates (joins) all selectors in selector array
+Extend.prototype.findSelfSelectors = function (selectors) {
+    var selfElements = [],
+        i,
+        selectorElements;
+
+    for (i = 0; i < selectors.length; i++) {
+        selectorElements = selectors[i].elements;
+        // duplicate the logic in genCSS function inside the selector node.
+        // future TODO - move both logics into the selector joiner visitor
+        if (i > 0 && selectorElements.length && selectorElements[0].combinator.value === "") {
+            selectorElements[0].combinator.value = ' ';
+        }
+        selfElements = selfElements.concat(selectors[i].elements);
+    }
+
+    this.selfSelectors = [new Selector(selfElements)];
+    this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
+};
+module.exports = Extend;

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

@@ -0,0 +1,165 @@
+var Node = require("./node"),
+    Media = require("./media"),
+    URL = require("./url"),
+    Quoted = require("./quoted"),
+    Ruleset = require("./ruleset"),
+    Anonymous = require("./anonymous");
+
+//
+// CSS @import node
+//
+// The general strategy here is that we don't want to wait
+// for the parsing to be completed, before we start importing
+// the file. That's because in the context of a browser,
+// most of the time will be spent waiting for the server to respond.
+//
+// On creation, we push the import path to our import queue, though
+// `import,push`, we also pass it a callback, which it'll call once
+// the file has been fetched, and parsed.
+//
+var Import = function (path, features, options, index, currentFileInfo, visibilityInfo) {
+    this.options = options;
+    this.index = index;
+    this.path = path;
+    this.features = features;
+    this.currentFileInfo = currentFileInfo;
+
+    if (this.options.less !== undefined || this.options.inline) {
+        this.css = !this.options.less || this.options.inline;
+    } else {
+        var pathValue = this.getPath();
+        if (pathValue && /[#\.\&\?\/]css([\?;].*)?$/.test(pathValue)) {
+            this.css = true;
+        }
+    }
+    this.copyVisibilityInfo(visibilityInfo);
+};
+
+//
+// The actual import node doesn't return anything, when converted to CSS.
+// The reason is that it's used at the evaluation stage, so that the rules
+// it imports can be treated like any other rules.
+//
+// In `eval`, we make sure all Import nodes get evaluated, recursively, so
+// we end up with a flat structure, which can easily be imported in the parent
+// ruleset.
+//
+Import.prototype = new Node();
+Import.prototype.type = "Import";
+Import.prototype.accept = function (visitor) {
+    if (this.features) {
+        this.features = visitor.visit(this.features);
+    }
+    this.path = visitor.visit(this.path);
+    if (!this.options.plugin && !this.options.inline && this.root) {
+        this.root = visitor.visit(this.root);
+    }
+};
+Import.prototype.genCSS = function (context, output) {
+    if (this.css && this.path.currentFileInfo.reference === undefined) {
+        output.add("@import ", this.currentFileInfo, this.index);
+        this.path.genCSS(context, output);
+        if (this.features) {
+            output.add(" ");
+            this.features.genCSS(context, output);
+        }
+        output.add(';');
+    }
+};
+Import.prototype.getPath = function () {
+    return (this.path instanceof URL) ?
+        this.path.value.value : this.path.value;
+};
+Import.prototype.isVariableImport = function () {
+    var path = this.path;
+    if (path instanceof URL) {
+        path = path.value;
+    }
+    if (path instanceof Quoted) {
+        return path.containsVariables();
+    }
+
+    return true;
+};
+Import.prototype.evalForImport = function (context) {
+    var path = this.path;
+
+    if (path instanceof URL) {
+        path = path.value;
+    }
+
+    return new Import(path.eval(context), this.features, this.options, this.index, this.currentFileInfo, this.visibilityInfo());
+};
+Import.prototype.evalPath = function (context) {
+    var path = this.path.eval(context);
+    var rootpath = this.currentFileInfo && this.currentFileInfo.rootpath;
+
+    if (!(path instanceof URL)) {
+        if (rootpath) {
+            var pathValue = path.value;
+            // Add the base path if the import is relative
+            if (pathValue && context.isPathRelative(pathValue)) {
+                path.value = rootpath + pathValue;
+            }
+        }
+        path.value = context.normalizePath(path.value);
+    }
+
+    return path;
+};
+Import.prototype.eval = function (context) {
+    var result = this.doEval(context);
+    if (this.options.reference || this.blocksVisibility()) {
+        if (result.length || result.length === 0) {
+            result.forEach(function (node) {
+                    node.addVisibilityBlock();
+                }
+            );
+        } else {
+            result.addVisibilityBlock();
+        }
+    }
+    return result;
+};
+Import.prototype.doEval = function (context) {
+    var ruleset, registry,
+        features = this.features && this.features.eval(context);
+
+    if (this.options.plugin) {
+        registry = context.frames[0] && context.frames[0].functionRegistry;
+        if ( registry && this.root && this.root.functions ) {
+            registry.addMultiple( this.root.functions );
+        }
+        return [];
+    }
+
+    if (this.skip) {
+        if (typeof this.skip === "function") {
+            this.skip = this.skip();
+        }
+        if (this.skip) {
+            return [];
+        }
+    }
+    if (this.options.inline) {
+        var contents = new Anonymous(this.root, 0,
+          {
+              filename: this.importedFilename,
+              reference: this.path.currentFileInfo && this.path.currentFileInfo.reference
+          }, true, true);
+
+        return this.features ? new Media([contents], this.features.value) : [contents];
+    } else if (this.css) {
+        var newImport = new Import(this.evalPath(context), features, this.options, this.index);
+        if (!newImport.css && this.error) {
+            throw this.error;
+        }
+        return newImport;
+    } else {
+        ruleset = new Ruleset(null, this.root.rules.slice(0));
+        ruleset.evalImports(context);
+
+        return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;
+    }
+};
+module.exports = Import;

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

@@ -0,0 +1,41 @@
+var tree = {};
+
+tree.Node = require('./node');
+tree.Alpha = require('./alpha');
+tree.Color = require('./color');
+tree.Directive = require('./directive');
+tree.DetachedRuleset = require('./detached-ruleset');
+tree.Operation = require('./operation');
+tree.Dimension = require('./dimension');
+tree.Unit = require('./unit');
+tree.Keyword = require('./keyword');
+tree.Variable = require('./variable');
+tree.Ruleset = require('./ruleset');
+tree.Element = require('./element');
+tree.Attribute = require('./attribute');
+tree.Combinator = require('./combinator');
+tree.Selector = require('./selector');
+tree.Quoted = require('./quoted');
+tree.Expression = require('./expression');
+tree.Rule = require('./rule');
+tree.Call = require('./call');
+tree.URL = require('./url');
+tree.Import = require('./import');
+tree.mixin = {
+    Call: require('./mixin-call'),
+    Definition: require('./mixin-definition')
+};
+tree.Comment = require('./comment');
+tree.Anonymous = require('./anonymous');
+tree.Value = require('./value');
+tree.JavaScript = require('./javascript');
+tree.Assignment = require('./assignment');
+tree.Condition = require('./condition');
+tree.Paren = require('./paren');
+tree.Media = require('./media');
+tree.UnicodeDescriptor = require('./unicode-descriptor');
+tree.Negative = require('./negative');
+tree.Extend = require('./extend');
+tree.RulesetCall = require('./ruleset-call');
+
+module.exports = tree;

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

@@ -0,0 +1,28 @@
+var JsEvalNode = require("./js-eval-node"),
+    Dimension = require("./dimension"),
+    Quoted = require("./quoted"),
+    Anonymous = require("./anonymous");
+
+var JavaScript = function (string, escaped, index, currentFileInfo) {
+    this.escaped = escaped;
+    this.expression = string;
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+};
+JavaScript.prototype = new JsEvalNode();
+JavaScript.prototype.type = "JavaScript";
+JavaScript.prototype.eval = function(context) {
+    var result = this.evaluateJavaScript(this.expression, context);
+
+    if (typeof result === 'number') {
+        return new Dimension(result);
+    } else if (typeof result === 'string') {
+        return new Quoted('"' + result + '"', result, this.escaped, this.index);
+    } else if (Array.isArray(result)) {
+        return new Anonymous(result.join(', '));
+    } else {
+        return new Anonymous(result);
+    }
+};
+
+module.exports = JavaScript;

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

@@ -0,0 +1,61 @@
+var Node = require("./node"),
+    Variable = require("./variable");
+
+var JsEvalNode = function() {
+};
+JsEvalNode.prototype = new Node();
+
+JsEvalNode.prototype.evaluateJavaScript = function (expression, context) {
+    var result,
+        that = this,
+        evalContext = {};
+
+    if (context.javascriptEnabled !== undefined && !context.javascriptEnabled) {
+        throw { message: "You are using JavaScript, which has been disabled.",
+            filename: this.currentFileInfo.filename,
+            index: this.index };
+    }
+
+    expression = expression.replace(/@\{([\w-]+)\}/g, function (_, name) {
+        return that.jsify(new Variable('@' + name, that.index, that.currentFileInfo).eval(context));
+    });
+
+    try {
+        expression = new Function('return (' + expression + ')');
+    } catch (e) {
+        throw { message: "JavaScript evaluation error: " + e.message + " from `" + expression + "`" ,
+            filename: this.currentFileInfo.filename,
+            index: this.index };
+    }
+
+    var variables = context.frames[0].variables();
+    for (var k in variables) {
+        if (variables.hasOwnProperty(k)) {
+            /*jshint loopfunc:true */
+            evalContext[k.slice(1)] = {
+                value: variables[k].value,
+                toJS: function () {
+                    return this.value.eval(context).toCSS();
+                }
+            };
+        }
+    }
+
+    try {
+        result = expression.call(evalContext);
+    } catch (e) {
+        throw { message: "JavaScript evaluation error: '" + e.name + ': ' + e.message.replace(/["]/g, "'") + "'" ,
+            filename: this.currentFileInfo.filename,
+            index: this.index };
+    }
+    return result;
+};
+JsEvalNode.prototype.jsify = function (obj) {
+    if (Array.isArray(obj.value) && (obj.value.length > 1)) {
+        return '[' + obj.value.map(function (v) { return v.toCSS(); }).join(', ') + ']';
+    } else {
+        return obj.toCSS();
+    }
+};
+
+module.exports = JsEvalNode;

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

@@ -0,0 +1,14 @@
+var Node = require("./node");
+
+var Keyword = function (value) { this.value = value; };
+Keyword.prototype = new Node();
+Keyword.prototype.type = "Keyword";
+Keyword.prototype.genCSS = function (context, output) {
+    if (this.value === '%') { throw { type: "Syntax", message: "Invalid % without number" }; }
+    output.add(this.value);
+};
+
+Keyword.True = new Keyword('true');
+Keyword.False = new Keyword('false');
+
+module.exports = Keyword;

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

@@ -0,0 +1,144 @@
+var Ruleset = require("./ruleset"),
+    Value = require("./value"),
+    Selector = require("./selector"),
+    Anonymous = require("./anonymous"),
+    Expression = require("./expression"),
+    Directive = require("./directive");
+
+var Media = function (value, features, index, currentFileInfo, visibilityInfo) {
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+
+    var selectors = (new Selector([], null, null, this.index, this.currentFileInfo)).createEmptySelectors();
+
+    this.features = new Value(features);
+    this.rules = [new Ruleset(selectors, value)];
+    this.rules[0].allowImports = true;
+    this.copyVisibilityInfo(visibilityInfo);
+};
+Media.prototype = new Directive();
+Media.prototype.type = "Media";
+Media.prototype.isRulesetLike = true;
+Media.prototype.accept = function (visitor) {
+    if (this.features) {
+        this.features = visitor.visit(this.features);
+    }
+    if (this.rules) {
+        this.rules = visitor.visitArray(this.rules);
+    }
+};
+Media.prototype.genCSS = function (context, output) {
+    output.add('@media ', this.currentFileInfo, this.index);
+    this.features.genCSS(context, output);
+    this.outputRuleset(context, output, this.rules);
+};
+Media.prototype.eval = function (context) {
+    if (!context.mediaBlocks) {
+        context.mediaBlocks = [];
+        context.mediaPath = [];
+    }
+
+    var media = new Media(null, [], this.index, this.currentFileInfo, this.visibilityInfo());
+    if (this.debugInfo) {
+        this.rules[0].debugInfo = this.debugInfo;
+        media.debugInfo = this.debugInfo;
+    }
+    var strictMathBypass = false;
+    if (!context.strictMath) {
+        strictMathBypass = true;
+        context.strictMath = true;
+    }
+    try {
+        media.features = this.features.eval(context);
+    }
+    finally {
+        if (strictMathBypass) {
+            context.strictMath = false;
+        }
+    }
+
+    context.mediaPath.push(media);
+    context.mediaBlocks.push(media);
+
+    this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
+    context.frames.unshift(this.rules[0]);
+    media.rules = [this.rules[0].eval(context)];
+    context.frames.shift();
+
+    context.mediaPath.pop();
+
+    return context.mediaPath.length === 0 ? media.evalTop(context) :
+                media.evalNested(context);
+};
+Media.prototype.evalTop = function (context) {
+    var result = this;
+
+    // Render all dependent Media blocks.
+    if (context.mediaBlocks.length > 1) {
+        var selectors = (new Selector([], null, null, this.index, this.currentFileInfo)).createEmptySelectors();
+        result = new Ruleset(selectors, context.mediaBlocks);
+        result.multiMedia = true;
+        result.copyVisibilityInfo(this.visibilityInfo());
+    }
+
+    delete context.mediaBlocks;
+    delete context.mediaPath;
+
+    return result;
+};
+Media.prototype.evalNested = function (context) {
+    var i, value,
+        path = context.mediaPath.concat([this]);
+
+    // Extract the media-query conditions separated with `,` (OR).
+    for (i = 0; i < path.length; i++) {
+        value = path[i].features instanceof Value ?
+                    path[i].features.value : path[i].features;
+        path[i] = Array.isArray(value) ? value : [value];
+    }
+
+    // Trace all permutations to generate the resulting media-query.
+    //
+    // (a, b and c) with nested (d, e) ->
+    //    a and d
+    //    a and e
+    //    b and c and d
+    //    b and c and e
+    this.features = new Value(this.permute(path).map(function (path) {
+        path = path.map(function (fragment) {
+            return fragment.toCSS ? fragment : new Anonymous(fragment);
+        });
+
+        for (i = path.length - 1; i > 0; i--) {
+            path.splice(i, 0, new Anonymous("and"));
+        }
+
+        return new Expression(path);
+    }));
+
+    // Fake a tree-node that doesn't output anything.
+    return new Ruleset([], []);
+};
+Media.prototype.permute = function (arr) {
+    if (arr.length === 0) {
+        return [];
+    } else if (arr.length === 1) {
+        return arr[0];
+    } else {
+        var result = [];
+        var rest = this.permute(arr.slice(1));
+        for (var i = 0; i < rest.length; i++) {
+            for (var j = 0; j < arr[0].length; j++) {
+                result.push([arr[0][j]].concat(rest[i]));
+            }
+        }
+        return result;
+    }
+};
+Media.prototype.bubbleSelectors = function (selectors) {
+    if (!selectors) {
+        return;
+    }
+    this.rules = [new Ruleset(selectors.slice(0), [this.rules[0]])];
+};
+module.exports = Media;