less-execjs 2.6.0.3

data/lib/less/js/less/lib/less/visitors/import-sequencer.js

@@ -0,0 +1,54 @@
+function ImportSequencer(onSequencerEmpty) {
+    this.imports = [];
+    this.variableImports = [];
+    this._onSequencerEmpty = onSequencerEmpty;
+    this._currentDepth = 0;
+}
+
+ImportSequencer.prototype.addImport = function(callback) {
+    var importSequencer = this,
+        importItem = {
+            callback: callback,
+            args: null,
+            isReady: false
+        };
+    this.imports.push(importItem);
+    return function() {
+        importItem.args = Array.prototype.slice.call(arguments, 0);
+        importItem.isReady = true;
+        importSequencer.tryRun();
+    };
+};
+
+ImportSequencer.prototype.addVariableImport = function(callback) {
+    this.variableImports.push(callback);
+};
+
+ImportSequencer.prototype.tryRun = function() {
+    this._currentDepth++;
+    try {
+        while (true) {
+            while (this.imports.length > 0) {
+                var importItem = this.imports[0];
+                if (!importItem.isReady) {
+                    return;
+                }
+                this.imports = this.imports.slice(1);
+                importItem.callback.apply(null, importItem.args);
+            }
+            if (this.variableImports.length === 0) {
+                break;
+            }
+            var variableImport = this.variableImports[0];
+            this.variableImports = this.variableImports.slice(1);
+            variableImport();
+        }
+    } finally {
+        this._currentDepth--;
+    }
+    if (this._currentDepth === 0 && this._onSequencerEmpty) {
+        this._onSequencerEmpty();
+    }
+};
+
+module.exports = ImportSequencer;

data/lib/less/js/less/lib/less/visitors/import-visitor.js

@@ -0,0 +1,189 @@
+var contexts = require("../contexts"),
+    Visitor = require("./visitor"),
+    ImportSequencer = require("./import-sequencer");
+
+var ImportVisitor = function(importer, finish) {
+
+    this._visitor = new Visitor(this);
+    this._importer = importer;
+    this._finish = finish;
+    this.context = new contexts.Eval();
+    this.importCount = 0;
+    this.onceFileDetectionMap = {};
+    this.recursionDetector = {};
+    this._sequencer = new ImportSequencer(this._onSequencerEmpty.bind(this));
+};
+
+ImportVisitor.prototype = {
+    isReplacing: false,
+    run: function (root) {
+        try {
+            // process the contents
+            this._visitor.visit(root);
+        }
+        catch(e) {
+            this.error = e;
+        }
+
+        this.isFinished = true;
+        this._sequencer.tryRun();
+    },
+    _onSequencerEmpty: function() {
+        if (!this.isFinished) {
+            return;
+        }
+        this._finish(this.error);
+    },
+    visitImport: function (importNode, visitArgs) {
+        var inlineCSS = importNode.options.inline;
+
+        if (!importNode.css || inlineCSS) {
+
+            var context = new contexts.Eval(this.context, this.context.frames.slice(0));
+            var importParent = context.frames[0];
+
+            this.importCount++;
+            if (importNode.isVariableImport()) {
+                this._sequencer.addVariableImport(this.processImportNode.bind(this, importNode, context, importParent));
+            } else {
+                this.processImportNode(importNode, context, importParent);
+            }
+        }
+        visitArgs.visitDeeper = false;
+    },
+    processImportNode: function(importNode, context, importParent) {
+        var evaldImportNode,
+            inlineCSS = importNode.options.inline;
+
+        try {
+            evaldImportNode = importNode.evalForImport(context);
+        } catch(e) {
+            if (!e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+            // attempt to eval properly and treat as css
+            importNode.css = true;
+            // if that fails, this error will be thrown
+            importNode.error = e;
+        }
+
+        if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {
+
+            if (evaldImportNode.options.multiple) {
+                context.importMultiple = true;
+            }
+
+            // try appending if we haven't determined if it is css or not
+            var tryAppendLessExtension = evaldImportNode.css === undefined;
+
+            for (var i = 0; i < importParent.rules.length; i++) {
+                if (importParent.rules[i] === importNode) {
+                    importParent.rules[i] = evaldImportNode;
+                    break;
+                }
+            }
+
+            var onImported = this.onImported.bind(this, evaldImportNode, context),
+                sequencedOnImported = this._sequencer.addImport(onImported);
+
+            this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.currentFileInfo,
+                evaldImportNode.options, sequencedOnImported);
+        } else {
+            this.importCount--;
+            if (this.isFinished) {
+                this._sequencer.tryRun();
+            }
+        }
+    },
+    onImported: function (importNode, context, e, root, importedAtRoot, fullPath) {
+        if (e) {
+            if (!e.filename) {
+                e.index = importNode.index; e.filename = importNode.currentFileInfo.filename;
+            }
+            this.error = e;
+        }
+
+        var importVisitor = this,
+            inlineCSS = importNode.options.inline,
+            isPlugin = importNode.options.plugin,
+            isOptional = importNode.options.optional,
+            duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
+
+        if (!context.importMultiple) {
+            if (duplicateImport) {
+                importNode.skip = true;
+            } else {
+                importNode.skip = function() {
+                    if (fullPath in importVisitor.onceFileDetectionMap) {
+                        return true;
+                    }
+                    importVisitor.onceFileDetectionMap[fullPath] = true;
+                    return false;
+                };
+            }
+        }
+
+        if (!fullPath && isOptional) {
+            importNode.skip = true;
+        }
+
+        if (root) {
+            importNode.root = root;
+            importNode.importedFilename = fullPath;
+
+            if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {
+                importVisitor.recursionDetector[fullPath] = true;
+
+                var oldContext = this.context;
+                this.context = context;
+                try {
+                    this._visitor.visit(root);
+                } catch (e) {
+                    this.error = e;
+                }
+                this.context = oldContext;
+            }
+        }
+
+        importVisitor.importCount--;
+
+        if (importVisitor.isFinished) {
+            importVisitor._sequencer.tryRun();
+        }
+    },
+    visitRule: function (ruleNode, visitArgs) {
+        if (ruleNode.value.type === "DetachedRuleset") {
+            this.context.frames.unshift(ruleNode);
+        } else {
+            visitArgs.visitDeeper = false;
+        }
+    },
+    visitRuleOut : function(ruleNode) {
+        if (ruleNode.value.type === "DetachedRuleset") {
+            this.context.frames.shift();
+        }
+    },
+    visitDirective: function (directiveNode, visitArgs) {
+        this.context.frames.unshift(directiveNode);
+    },
+    visitDirectiveOut: function (directiveNode) {
+        this.context.frames.shift();
+    },
+    visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+        this.context.frames.unshift(mixinDefinitionNode);
+    },
+    visitMixinDefinitionOut: function (mixinDefinitionNode) {
+        this.context.frames.shift();
+    },
+    visitRuleset: function (rulesetNode, visitArgs) {
+        this.context.frames.unshift(rulesetNode);
+    },
+    visitRulesetOut: function (rulesetNode) {
+        this.context.frames.shift();
+    },
+    visitMedia: function (mediaNode, visitArgs) {
+        this.context.frames.unshift(mediaNode.rules[0]);
+    },
+    visitMediaOut: function (mediaNode) {
+        this.context.frames.shift();
+    }
+};
+module.exports = ImportVisitor;

data/lib/less/js/less/lib/less/visitors/index.js

@@ -0,0 +1,10 @@
+var visitors = {
+    Visitor: require("./visitor"),
+    ImportVisitor: require('./import-visitor'),
+    MarkVisibleSelectorsVisitor: require("./set-tree-visibility-visitor"),
+    ExtendVisitor: require('./extend-visitor'),
+    JoinSelectorVisitor: require('./join-selector-visitor'),
+    ToCSSVisitor: require('./to-css-visitor')
+};
+
+module.exports = visitors;

data/lib/less/js/less/lib/less/visitors/join-selector-visitor.js

@@ -0,0 +1,51 @@
+var Visitor = require("./visitor");
+
+var JoinSelectorVisitor = function() {
+    this.contexts = [[]];
+    this._visitor = new Visitor(this);
+};
+
+JoinSelectorVisitor.prototype = {
+    run: function (root) {
+        return this._visitor.visit(root);
+    },
+    visitRule: function (ruleNode, visitArgs) {
+        visitArgs.visitDeeper = false;
+    },
+    visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+        visitArgs.visitDeeper = false;
+    },
+
+    visitRuleset: function (rulesetNode, visitArgs) {
+        var context = this.contexts[this.contexts.length - 1],
+            paths = [], selectors;
+
+        this.contexts.push(paths);
+
+        if (! rulesetNode.root) {
+            selectors = rulesetNode.selectors;
+            if (selectors) {
+                selectors = selectors.filter(function(selector) { return selector.getIsOutput(); });
+                rulesetNode.selectors = selectors.length ? selectors : (selectors = null);
+                if (selectors) { rulesetNode.joinSelectors(paths, context, selectors); }
+            }
+            if (!selectors) { rulesetNode.rules = null; }
+            rulesetNode.paths = paths;
+        }
+    },
+    visitRulesetOut: function (rulesetNode) {
+        this.contexts.length = this.contexts.length - 1;
+    },
+    visitMedia: function (mediaNode, visitArgs) {
+        var context = this.contexts[this.contexts.length - 1];
+        mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);
+    },
+    visitDirective: function (directiveNode, visitArgs) {
+        var context = this.contexts[this.contexts.length - 1];
+        if (directiveNode.rules && directiveNode.rules.length) {
+            directiveNode.rules[0].root = (directiveNode.isRooted || context.length === 0 || null);
+        }
+    }
+};
+
+module.exports = JoinSelectorVisitor;

data/lib/less/js/less/lib/less/visitors/set-tree-visibility-visitor.js

@@ -0,0 +1,38 @@
+var SetTreeVisibilityVisitor = function(visible) {
+    this.visible = visible;
+};
+SetTreeVisibilityVisitor.prototype.run = function(root) {
+    this.visit(root);
+};
+SetTreeVisibilityVisitor.prototype.visitArray = function(nodes) {
+    if (!nodes) {
+        return nodes;
+    }
+
+    var cnt = nodes.length, i;
+    for (i = 0; i < cnt; i++) {
+        this.visit(nodes[i]);
+    }
+    return nodes;
+};
+SetTreeVisibilityVisitor.prototype.visit = function(node) {
+    if (!node) {
+        return node;
+    }
+    if (node.constructor === Array) {
+        return this.visitArray(node);
+    }
+
+    if (!node.blocksVisibility || node.blocksVisibility()) {
+        return node;
+    }
+    if (this.visible) {
+        node.ensureVisibility();
+    } else {
+        node.ensureInvisibility();
+    }
+
+    node.accept(this);
+    return node;
+};
+module.exports = SetTreeVisibilityVisitor;

data/lib/less/js/less/lib/less/visitors/to-css-visitor.js

@@ -0,0 +1,383 @@
+var tree = require("../tree"),
+    Visitor = require("./visitor");
+
+var CSSVisitorUtils = function(context) {
+    this._visitor = new Visitor(this);
+    this._context = context;
+};
+
+CSSVisitorUtils.prototype = {
+    containsSilentNonBlockedChild: function(bodyRules) {
+        var rule;
+        if (bodyRules == null) {
+            return false;
+        }
+        for (var r = 0; r < bodyRules.length; r++) {
+            rule = bodyRules[r];
+            if (rule.isSilent && rule.isSilent(this._context) && !rule.blocksVisibility()) {
+                //the directive contains something that was referenced (likely by extend)
+                //therefore it needs to be shown in output too
+                return true;
+            }
+        }
+        return false;
+    },
+
+    keepOnlyVisibleChilds: function(owner) {
+        if (owner == null || owner.rules == null) {
+            return ;
+        }
+
+        owner.rules = owner.rules.filter(function(thing) {
+                return thing.isVisible();
+            }
+        );
+    },
+
+    isEmpty: function(owner) {
+        if (owner == null || owner.rules == null) {
+            return true;
+        }
+        return owner.rules.length === 0;
+    },
+
+    hasVisibleSelector: function(rulesetNode) {
+        if (rulesetNode == null || rulesetNode.paths == null) {
+            return false;
+        }
+        return rulesetNode.paths.length > 0;
+    },
+
+    resolveVisibility: function (node, originalRules) {
+        if (!node.blocksVisibility()) {
+            if (this.isEmpty(node) && !this.containsSilentNonBlockedChild(originalRules)) {
+                return ;
+            }
+
+            return node;
+        }
+
+        var compiledRulesBody = node.rules[0];
+        this.keepOnlyVisibleChilds(compiledRulesBody);
+
+        if (this.isEmpty(compiledRulesBody)) {
+            return ;
+        }
+
+        node.ensureVisibility();
+        node.removeVisibilityBlock();
+
+        return node;
+    },
+
+    isVisibleRuleset: function(rulesetNode) {
+        if (rulesetNode.firstRoot) {
+            return true;
+        }
+
+        if (this.isEmpty(rulesetNode)) {
+            return false;
+        }
+
+        if (!rulesetNode.root && !this.hasVisibleSelector(rulesetNode)) {
+            return false;
+        }
+
+        return true;
+    }
+
+};
+
+var ToCSSVisitor = function(context) {
+    this._visitor = new Visitor(this);
+    this._context = context;
+    this.utils = new CSSVisitorUtils(context);
+};
+
+ToCSSVisitor.prototype = {
+    isReplacing: true,
+    run: function (root) {
+        return this._visitor.visit(root);
+    },
+
+    visitRule: function (ruleNode, visitArgs) {
+        if (ruleNode.blocksVisibility() || ruleNode.variable) {
+            return;
+        }
+        return ruleNode;
+    },
+
+    visitMixinDefinition: function (mixinNode, visitArgs) {
+        // mixin definitions do not get eval'd - this means they keep state
+        // so we have to clear that state here so it isn't used if toCSS is called twice
+        mixinNode.frames = [];
+    },
+
+    visitExtend: function (extendNode, visitArgs) {
+    },
+
+    visitComment: function (commentNode, visitArgs) {
+        if (commentNode.blocksVisibility() || commentNode.isSilent(this._context)) {
+            return;
+        }
+        return commentNode;
+    },
+
+    visitMedia: function(mediaNode, visitArgs) {
+        var originalRules = mediaNode.rules[0].rules;
+        mediaNode.accept(this._visitor);
+        visitArgs.visitDeeper = false;
+
+        return this.utils.resolveVisibility(mediaNode, originalRules);
+    },
+
+    visitImport: function (importNode, visitArgs) {
+        if (importNode.blocksVisibility()) {
+            return ;
+        }
+        return importNode;
+    },
+
+    visitDirective: function(directiveNode, visitArgs) {
+        if (directiveNode.rules && directiveNode.rules.length) {
+            return this.visitDirectiveWithBody(directiveNode, visitArgs);
+        } else {
+            return this.visitDirectiveWithoutBody(directiveNode, visitArgs);
+        }
+        return directiveNode;
+    },
+
+    visitDirectiveWithBody: function(directiveNode, visitArgs) {
+        //if there is only one nested ruleset and that one has no path, then it is
+        //just fake ruleset
+        function hasFakeRuleset(directiveNode) {
+            var bodyRules = directiveNode.rules;
+            return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);
+        }
+        function getBodyRules(directiveNode) {
+            var nodeRules = directiveNode.rules;
+            if (hasFakeRuleset(directiveNode)) {
+                return nodeRules[0].rules;
+            }
+
+            return nodeRules;
+        }
+        //it is still true that it is only one ruleset in array
+        //this is last such moment
+        //process childs
+        var originalRules = getBodyRules(directiveNode);
+        directiveNode.accept(this._visitor);
+        visitArgs.visitDeeper = false;
+
+        if (!this.utils.isEmpty(directiveNode)) {
+            this._mergeRules(directiveNode.rules[0].rules);
+        }
+
+        return this.utils.resolveVisibility(directiveNode, originalRules);
+    },
+
+    visitDirectiveWithoutBody: function(directiveNode, visitArgs) {
+        if (directiveNode.blocksVisibility()) {
+            return;
+        }
+
+        if (directiveNode.name === "@charset") {
+            // Only output the debug info together with subsequent @charset definitions
+            // a comment (or @media statement) before the actual @charset directive would
+            // be considered illegal css as it has to be on the first line
+            if (this.charset) {
+                if (directiveNode.debugInfo) {
+                    var comment = new tree.Comment("/* " + directiveNode.toCSS(this._context).replace(/\n/g, "") + " */\n");
+                    comment.debugInfo = directiveNode.debugInfo;
+                    return this._visitor.visit(comment);
+                }
+                return;
+            }
+            this.charset = true;
+        }
+
+        return directiveNode;
+    },
+
+    checkPropertiesInRoot: function(rules) {
+        var ruleNode;
+        for (var i = 0; i < rules.length; i++) {
+            ruleNode = rules[i];
+            if (ruleNode instanceof tree.Rule && !ruleNode.variable) {
+                throw { message: "properties must be inside selector blocks, they cannot be in the root.",
+                    index: ruleNode.index, filename: ruleNode.currentFileInfo ? ruleNode.currentFileInfo.filename : null};
+            }
+        }
+    },
+
+    visitRuleset: function (rulesetNode, visitArgs) {
+        //at this point rulesets are nested into each other
+        var rule, rulesets = [];
+        if (rulesetNode.firstRoot) {
+            this.checkPropertiesInRoot(rulesetNode.rules);
+        }
+        if (! rulesetNode.root) {
+            //remove invisible paths
+            this._compileRulesetPaths(rulesetNode);
+
+            // remove rulesets from this ruleset body and compile them separately
+            var nodeRules = rulesetNode.rules, nodeRuleCnt = nodeRules ? nodeRules.length : 0;
+            for (var i = 0; i < nodeRuleCnt; ) {
+                rule = nodeRules[i];
+                if (rule && rule.rules) {
+                    // visit because we are moving them out from being a child
+                    rulesets.push(this._visitor.visit(rule));
+                    nodeRules.splice(i, 1);
+                    nodeRuleCnt--;
+                    continue;
+                }
+                i++;
+            }
+            // accept the visitor to remove rules and refactor itself
+            // then we can decide nogw whether we want it or not
+            // compile body
+            if (nodeRuleCnt > 0) {
+                rulesetNode.accept(this._visitor);
+            } else {
+                rulesetNode.rules = null;
+            }
+            visitArgs.visitDeeper = false;
+
+        } else { //if (! rulesetNode.root) {
+            rulesetNode.accept(this._visitor);
+            visitArgs.visitDeeper = false;
+        }
+
+        if (rulesetNode.rules) {
+            this._mergeRules(rulesetNode.rules);
+            this._removeDuplicateRules(rulesetNode.rules);
+        }
+
+        //now decide whether we keep the ruleset
+        if (this.utils.isVisibleRuleset(rulesetNode)) {
+            rulesetNode.ensureVisibility();
+            rulesets.splice(0, 0, rulesetNode);
+        }
+
+        if (rulesets.length === 1) {
+            return rulesets[0];
+        }
+        return rulesets;
+    },
+
+    _compileRulesetPaths: function(rulesetNode) {
+        if (rulesetNode.paths) {
+            rulesetNode.paths = rulesetNode.paths
+                .filter(function(p) {
+                    var i;
+                    if (p[0].elements[0].combinator.value === ' ') {
+                        p[0].elements[0].combinator = new(tree.Combinator)('');
+                    }
+                    for (i = 0; i < p.length; i++) {
+                        if (p[i].isVisible() && p[i].getIsOutput()) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+        }
+    },
+
+    _removeDuplicateRules: function(rules) {
+        if (!rules) { return; }
+
+        // remove duplicates
+        var ruleCache = {},
+            ruleList, rule, i;
+
+        for (i = rules.length - 1; i >= 0 ; i--) {
+            rule = rules[i];
+            if (rule instanceof tree.Rule) {
+                if (!ruleCache[rule.name]) {
+                    ruleCache[rule.name] = rule;
+                } else {
+                    ruleList = ruleCache[rule.name];
+                    if (ruleList instanceof tree.Rule) {
+                        ruleList = ruleCache[rule.name] = [ruleCache[rule.name].toCSS(this._context)];
+                    }
+                    var ruleCSS = rule.toCSS(this._context);
+                    if (ruleList.indexOf(ruleCSS) !== -1) {
+                        rules.splice(i, 1);
+                    } else {
+                        ruleList.push(ruleCSS);
+                    }
+                }
+            }
+        }
+    },
+
+    _mergeRules: function (rules) {
+        if (!rules) { return; }
+
+        var groups = {},
+            parts,
+            rule,
+            key;
+
+        for (var i = 0; i < rules.length; i++) {
+            rule = rules[i];
+
+            if ((rule instanceof tree.Rule) && rule.merge) {
+                key = [rule.name,
+                    rule.important ? "!" : ""].join(",");
+
+                if (!groups[key]) {
+                    groups[key] = [];
+                } else {
+                    rules.splice(i--, 1);
+                }
+
+                groups[key].push(rule);
+            }
+        }
+
+        Object.keys(groups).map(function (k) {
+
+            function toExpression(values) {
+                return new (tree.Expression)(values.map(function (p) {
+                    return p.value;
+                }));
+            }
+
+            function toValue(values) {
+                return new (tree.Value)(values.map(function (p) {
+                    return p;
+                }));
+            }
+
+            parts = groups[k];
+
+            if (parts.length > 1) {
+                rule = parts[0];
+                var spacedGroups = [];
+                var lastSpacedGroup = [];
+                parts.map(function (p) {
+                    if (p.merge === "+") {
+                        if (lastSpacedGroup.length > 0) {
+                            spacedGroups.push(toExpression(lastSpacedGroup));
+                        }
+                        lastSpacedGroup = [];
+                    }
+                    lastSpacedGroup.push(p);
+                });
+                spacedGroups.push(toExpression(lastSpacedGroup));
+                rule.value = toValue(spacedGroups);
+            }
+        });
+    },
+
+    visitAnonymous: function(anonymousNode, visitArgs) {
+        if (anonymousNode.blocksVisibility()) {
+            return ;
+        }
+        anonymousNode.accept(this._visitor);
+        return anonymousNode;
+    }
+};
+
+module.exports = ToCSSVisitor;