less 3.9.0 → 3.10.1

package/lib/less/visitors/extend-visitor.js

@@ -1,37 +1,46 @@
-var tree = require('../tree'),
-    Visitor = require('./visitor'),
-    logger = require('../logger'),
-    utils = require('../utils');
+import tree from '../tree';
+import Visitor from './visitor';
+import logger from '../logger';
+import * as utils from '../utils';
 
 /* jshint loopfunc:true */
 
-var ExtendFinderVisitor = function() {
-    this._visitor = new Visitor(this);
-    this.contexts = [];
-    this.allExtendsStack = [[]];
-};
+class ExtendFinderVisitor {
+    constructor() {
+        this._visitor = new Visitor(this);
+        this.contexts = [];
+        this.allExtendsStack = [[]];
+    }
 
-ExtendFinderVisitor.prototype = {
-    run: function (root) {
+    run(root) {
         root = this._visitor.visit(root);
         root.allExtends = this.allExtendsStack[0];
         return root;
-    },
-    visitDeclaration: function (declNode, visitArgs) {
+    }
+
+    visitDeclaration(declNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    },
-    visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+    }
+
+    visitMixinDefinition(mixinDefinitionNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    },
-    visitRuleset: function (rulesetNode, visitArgs) {
+    }
+
+    visitRuleset(rulesetNode, visitArgs) {
         if (rulesetNode.root) {
             return;
         }
 
-        var i, j, extend, allSelectorsExtendList = [], extendList;
+        let i;
+        let j;
+        let extend;
+        const allSelectorsExtendList = [];
+        let extendList;
 
         // get &:extend(.a); rules which apply to all selectors in this ruleset
-        var rules = rulesetNode.rules, ruleCnt = rules ? rules.length : 0;
+        const rules = rulesetNode.rules;
+
+        const ruleCnt = rules ? rules.length : 0;
         for (i = 0; i < ruleCnt; i++) {
             if (rulesetNode.rules[i] instanceof tree.Extend) {
                 allSelectorsExtendList.push(rules[i]);
@@ -41,19 +50,17 @@ ExtendFinderVisitor.prototype = {
 
         // now find every selector and apply the extends that apply to all extends
         // and the ones which apply to an individual extend
-        var paths = rulesetNode.paths;
+        const paths = rulesetNode.paths;
         for (i = 0; i < paths.length; i++) {
-            var selectorPath = paths[i],
-                selector = selectorPath[selectorPath.length - 1],
-                selExtendList = selector.extendList;
+            const selectorPath = paths[i];
+            const selector = selectorPath[selectorPath.length - 1];
+            const selExtendList = selector.extendList;
 
             extendList = selExtendList ? utils.copyArray(selExtendList).concat(allSelectorsExtendList)
-                                       : allSelectorsExtendList;
+                : allSelectorsExtendList;
 
             if (extendList) {
-                extendList = extendList.map(function(allSelectorsExtend) {
-                    return allSelectorsExtend.clone();
-                });
+                extendList = extendList.map(allSelectorsExtend => allSelectorsExtend.clone());
             }
 
             for (j = 0; j < extendList.length; j++) {
@@ -67,62 +74,67 @@ ExtendFinderVisitor.prototype = {
         }
 
         this.contexts.push(rulesetNode.selectors);
-    },
-    visitRulesetOut: function (rulesetNode) {
+    }
+
+    visitRulesetOut(rulesetNode) {
         if (!rulesetNode.root) {
             this.contexts.length = this.contexts.length - 1;
         }
-    },
-    visitMedia: function (mediaNode, visitArgs) {
+    }
+
+    visitMedia(mediaNode, visitArgs) {
         mediaNode.allExtends = [];
         this.allExtendsStack.push(mediaNode.allExtends);
-    },
-    visitMediaOut: function (mediaNode) {
+    }
+
+    visitMediaOut(mediaNode) {
         this.allExtendsStack.length = this.allExtendsStack.length - 1;
-    },
-    visitAtRule: function (atRuleNode, visitArgs) {
+    }
+
+    visitAtRule(atRuleNode, visitArgs) {
         atRuleNode.allExtends = [];
         this.allExtendsStack.push(atRuleNode.allExtends);
-    },
-    visitAtRuleOut: function (atRuleNode) {
+    }
+
+    visitAtRuleOut(atRuleNode) {
         this.allExtendsStack.length = this.allExtendsStack.length - 1;
     }
-};
+}
 
-var ProcessExtendsVisitor = function() {
-    this._visitor = new Visitor(this);
-};
+class ProcessExtendsVisitor {
+    constructor() {
+        this._visitor = new Visitor(this);
+    }
 
-ProcessExtendsVisitor.prototype = {
-    run: function(root) {
-        var extendFinder = new ExtendFinderVisitor();
+    run(root) {
+        const extendFinder = new ExtendFinderVisitor();
         this.extendIndices = {};
         extendFinder.run(root);
         if (!extendFinder.foundExtends) { return root; }
         root.allExtends = root.allExtends.concat(this.doExtendChaining(root.allExtends, root.allExtends));
         this.allExtendsStack = [root.allExtends];
-        var newRoot = this._visitor.visit(root);
+        const newRoot = this._visitor.visit(root);
         this.checkExtendsForNonMatched(root.allExtends);
         return newRoot;
-    },
-    checkExtendsForNonMatched: function(extendList) {
-        var indices = this.extendIndices;
-        extendList.filter(function(extend) {
-            return !extend.hasFoundMatches && extend.parent_ids.length == 1;
-        }).forEach(function(extend) {
-            var selector = '_unknown_';
+    }
+
+    checkExtendsForNonMatched(extendList) {
+        const indices = this.extendIndices;
+        extendList.filter(extend => !extend.hasFoundMatches && extend.parent_ids.length == 1).forEach(extend => {
+            let selector = '_unknown_';
             try {
                 selector = extend.selector.toCSS({});
             }
             catch (_) {}
 
-            if (!indices[extend.index + ' ' + selector]) {
-                indices[extend.index + ' ' + selector] = true;
-                logger.warn('extend \'' + selector + '\' has no matches');
+            if (!indices[`${extend.index} ${selector}`]) {
+                indices[`${extend.index} ${selector}`] = true;
+                logger.warn(`extend '${selector}' has no matches`);
             }
         });
-    },
-    doExtendChaining: function (extendsList, extendsListTarget, iterationCount) {
+    }
+
+    doExtendChaining(extendsList, extendsListTarget, iterationCount) {
         //
         // chaining is different from normal extension.. if we extend an extend then we are not just copying, altering
         // and pasting the selector we would do normally, but we are also adding an extend with the same target selector
@@ -132,8 +144,17 @@ ProcessExtendsVisitor.prototype = {
         // this is also the most expensive.. and a match on one selector can cause an extension of a selector we had already
         // processed if we look at each selector at a time, as is done in visitRuleset
 
-        var extendIndex, targetExtendIndex, matches, extendsToAdd = [], newSelector, extendVisitor = this, selectorPath,
-            extend, targetExtend, newExtend;
+        let extendIndex;
+
+        let targetExtendIndex;
+        let matches;
+        const extendsToAdd = [];
+        let newSelector;
+        const extendVisitor = this;
+        let selectorPath;
+        let extend;
+        let targetExtend;
+        let newExtend;
 
         iterationCount = iterationCount || 0;
 
@@ -160,8 +181,8 @@ ProcessExtendsVisitor.prototype = {
                     extend.hasFoundMatches = true;
 
                     // we found a match, so for each self selector..
-                    extend.selfSelectors.forEach(function(selfSelector) {
-                        var info = targetExtend.visibilityInfo();
+                    extend.selfSelectors.forEach(selfSelector => {
+                        const info = targetExtend.visibilityInfo();
 
                         // process the extend as usual
                         newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector, extend.isVisible());
@@ -197,15 +218,14 @@ ProcessExtendsVisitor.prototype = {
             // may no longer be needed.
             this.extendChainCount++;
             if (iterationCount > 100) {
-                var selectorOne = '{unable to calculate}';
-                var selectorTwo = '{unable to calculate}';
+                let selectorOne = '{unable to calculate}';
+                let selectorTwo = '{unable to calculate}';
                 try {
                     selectorOne = extendsToAdd[0].selfSelectors[0].toCSS();
                     selectorTwo = extendsToAdd[0].selector.toCSS();
                 }
                 catch (e) {}
-                throw { message: 'extend circular reference detected. One of the circular extends is currently:' +
-                    selectorOne + ':extend(' + selectorTwo + ')'};
+                throw { message: `extend circular reference detected. One of the circular extends is currently:${selectorOne}:extend(${selectorTwo})`};
             }
 
             // now process the new extends on the existing rules so that we can handle a extending b extending c extending
@@ -214,22 +234,31 @@ ProcessExtendsVisitor.prototype = {
         } else {
             return extendsToAdd;
         }
-    },
-    visitDeclaration: function (ruleNode, visitArgs) {
+    }
+
+    visitDeclaration(ruleNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    },
-    visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+    }
+
+    visitMixinDefinition(mixinDefinitionNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    },
-    visitSelector: function (selectorNode, visitArgs) {
+    }
+
+    visitSelector(selectorNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    },
-    visitRuleset: function (rulesetNode, visitArgs) {
+    }
+
+    visitRuleset(rulesetNode, visitArgs) {
         if (rulesetNode.root) {
             return;
         }
-        var matches, pathIndex, extendIndex, allExtends = this.allExtendsStack[this.allExtendsStack.length - 1],
-            selectorsToAdd = [], extendVisitor = this, selectorPath;
+        let matches;
+        let pathIndex;
+        let extendIndex;
+        const allExtends = this.allExtendsStack[this.allExtendsStack.length - 1];
+        const selectorsToAdd = [];
+        const extendVisitor = this;
+        let selectorPath;
 
         // look at each selector path in the ruleset, find any extend matches and then copy, find and replace
 
@@ -239,7 +268,7 @@ ProcessExtendsVisitor.prototype = {
 
                 // extending extends happens initially, before the main pass
                 if (rulesetNode.extendOnEveryPath) { continue; }
-                var extendList = selectorPath[selectorPath.length - 1].extendList;
+                const extendList = selectorPath[selectorPath.length - 1].extendList;
                 if (extendList && extendList.length) { continue; }
 
                 matches = this.findMatch(allExtends[extendIndex], selectorPath);
@@ -247,8 +276,8 @@ ProcessExtendsVisitor.prototype = {
                 if (matches.length) {
                     allExtends[extendIndex].hasFoundMatches = true;
 
-                    allExtends[extendIndex].selfSelectors.forEach(function(selfSelector) {
-                        var extendedSelectors;
+                    allExtends[extendIndex].selfSelectors.forEach(selfSelector => {
+                        let extendedSelectors;
                         extendedSelectors = extendVisitor.extendSelector(matches, selectorPath, selfSelector, allExtends[extendIndex].isVisible());
                         selectorsToAdd.push(extendedSelectors);
                     });
@@ -256,17 +285,25 @@ ProcessExtendsVisitor.prototype = {
             }
         }
         rulesetNode.paths = rulesetNode.paths.concat(selectorsToAdd);
-    },
-    findMatch: function (extend, haystackSelectorPath) {
+    }
+
+    findMatch(extend, haystackSelectorPath) {
         //
         // look through the haystack selector path to try and find the needle - extend.selector
         // returns an array of selector matches that can then be replaced
         //
-        var haystackSelectorIndex, hackstackSelector, hackstackElementIndex, haystackElement,
-            targetCombinator, i,
-            extendVisitor = this,
-            needleElements = extend.selector.elements,
-            potentialMatches = [], potentialMatch, matches = [];
+        let haystackSelectorIndex;
+
+        let hackstackSelector;
+        let hackstackElementIndex;
+        let haystackElement;
+        let targetCombinator;
+        let i;
+        const extendVisitor = this;
+        const needleElements = extend.selector.elements;
+        const potentialMatches = [];
+        let potentialMatch;
+        const matches = [];
 
         // loop through the haystack elements
         for (haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
@@ -327,8 +364,9 @@ ProcessExtendsVisitor.prototype = {
             }
         }
         return matches;
-    },
-    isElementValuesEqual: function(elementValue1, elementValue2) {
+    }
+
+    isElementValuesEqual(elementValue1, elementValue2) {
         if (typeof elementValue1 === 'string' || typeof elementValue2 === 'string') {
             return elementValue1 === elementValue2;
         }
@@ -352,7 +390,7 @@ ProcessExtendsVisitor.prototype = {
             if (!(elementValue2 instanceof tree.Selector) || elementValue1.elements.length !== elementValue2.elements.length) {
                 return false;
             }
-            for (var i = 0; i  < elementValue1.elements.length; i++) {
+            for (let i = 0; i  < elementValue1.elements.length; i++) {
                 if (elementValue1.elements[i].combinator.value !== elementValue2.elements[i].combinator.value) {
                     if (i !== 0 || (elementValue1.elements[i].combinator.value || ' ') !== (elementValue2.elements[i].combinator.value || ' ')) {
                         return false;
@@ -365,19 +403,20 @@ ProcessExtendsVisitor.prototype = {
             return true;
         }
         return false;
-    },
-    extendSelector:function (matches, selectorPath, replacementSelector, isVisible) {
+    }
 
+    extendSelector(matches, selectorPath, replacementSelector, isVisible) {
         // for a set of matches, replace each match with the replacement selector
 
-        var currentSelectorPathIndex = 0,
-            currentSelectorPathElementIndex = 0,
-            path = [],
-            matchIndex,
-            selector,
-            firstElement,
-            match,
-            newElements;
+        let currentSelectorPathIndex = 0;
+
+        let currentSelectorPathElementIndex = 0;
+        let path = [];
+        let matchIndex;
+        let selector;
+        let firstElement;
+        let match;
+        let newElements;
 
         for (matchIndex = 0; matchIndex < matches.length; matchIndex++) {
             match = matches[matchIndex];
@@ -427,9 +466,9 @@ ProcessExtendsVisitor.prototype = {
         }
 
         path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));
-        path = path.map(function (currentValue) {
+        path = path.map(currentValue => {
             // we can re-use elements here, because the visibility property matters only for selectors
-            var derived = currentValue.createDerived(currentValue.elements);
+            const derived = currentValue.createDerived(currentValue.elements);
             if (isVisible) {
                 derived.ensureVisibility();
             } else {
@@ -438,25 +477,29 @@ ProcessExtendsVisitor.prototype = {
             return derived;
         });
         return path;
-    },
-    visitMedia: function (mediaNode, visitArgs) {
-        var newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
+    }
+
+    visitMedia(mediaNode, visitArgs) {
+        let newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
         newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));
         this.allExtendsStack.push(newAllExtends);
-    },
-    visitMediaOut: function (mediaNode) {
-        var lastIndex = this.allExtendsStack.length - 1;
+    }
+
+    visitMediaOut(mediaNode) {
+        const lastIndex = this.allExtendsStack.length - 1;
         this.allExtendsStack.length = lastIndex;
-    },
-    visitAtRule: function (atRuleNode, visitArgs) {
-        var newAllExtends = atRuleNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
+    }
+
+    visitAtRule(atRuleNode, visitArgs) {
+        let newAllExtends = atRuleNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
         newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, atRuleNode.allExtends));
         this.allExtendsStack.push(newAllExtends);
-    },
-    visitAtRuleOut: function (atRuleNode) {
-        var lastIndex = this.allExtendsStack.length - 1;
+    }
+
+    visitAtRuleOut(atRuleNode) {
+        const lastIndex = this.allExtendsStack.length - 1;
         this.allExtendsStack.length = lastIndex;
     }
-};
+}
 
-module.exports = ProcessExtendsVisitor;
+export default ProcessExtendsVisitor;

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

@@ -1,54 +1,58 @@
-function ImportSequencer(onSequencerEmpty) {
-    this.imports = [];
-    this.variableImports = [];
-    this._onSequencerEmpty = onSequencerEmpty;
-    this._currentDepth = 0;
-}
+class ImportSequencer {
+    constructor(onSequencerEmpty) {
+        this.imports = [];
+        this.variableImports = [];
+        this._onSequencerEmpty = onSequencerEmpty;
+        this._currentDepth = 0;
+    }
+
+    addImport(callback) {
+        const importSequencer = this;
 
-ImportSequencer.prototype.addImport = function(callback) {
-    var importSequencer = this,
-        importItem = {
-            callback: callback,
+        const importItem = {
+            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);
-};
+        this.imports.push(importItem);
+        return function(...args) {
+            importItem.args = Array.prototype.slice.call(args, 0);
+            importItem.isReady = true;
+            importSequencer.tryRun();
+        };
+    }
+
+    addVariableImport(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;
+    tryRun() {
+        this._currentDepth++;
+        try {
+            while (true) {
+                while (this.imports.length > 0) {
+                    const importItem = this.imports[0];
+                    if (!importItem.isReady) {
+                        return;
+                    }
+                    this.imports = this.imports.slice(1);
+                    importItem.callback.apply(null, importItem.args);
                 }
-                this.imports = this.imports.slice(1);
-                importItem.callback.apply(null, importItem.args);
-            }
-            if (this.variableImports.length === 0) {
-                break;
+                if (this.variableImports.length === 0) {
+                    break;
+                }
+                const variableImport = this.variableImports[0];
+                this.variableImports = this.variableImports.slice(1);
+                variableImport();
             }
-            var variableImport = this.variableImports[0];
-            this.variableImports = this.variableImports.slice(1);
-            variableImport();
+        } finally {
+            this._currentDepth--;
+        }
+        if (this._currentDepth === 0 && this._onSequencerEmpty) {
+            this._onSequencerEmpty();
         }
-    } finally {
-        this._currentDepth--;
-    }
-    if (this._currentDepth === 0 && this._onSequencerEmpty) {
-        this._onSequencerEmpty();
     }
-};
+}
 
-module.exports = ImportSequencer;
+export default ImportSequencer;

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

@@ -1,9 +1,9 @@
-var contexts = require('../contexts'),
-    Visitor = require('./visitor'),
-    ImportSequencer = require('./import-sequencer'),
-    utils = require('../utils');
+import contexts from '../contexts';
+import Visitor from './visitor';
+import ImportSequencer from './import-sequencer';
+import * as utils from '../utils';
 
-var ImportVisitor = function(importer, finish) {
+const ImportVisitor = function(importer, finish) {
 
     this._visitor = new Visitor(this);
     this._importer = importer;
@@ -36,12 +36,12 @@ ImportVisitor.prototype = {
         this._finish(this.error);
     },
     visitImport: function (importNode, visitArgs) {
-        var inlineCSS = importNode.options.inline;
+        const inlineCSS = importNode.options.inline;
 
         if (!importNode.css || inlineCSS) {
 
-            var context = new contexts.Eval(this.context, utils.copyArray(this.context.frames));
-            var importParent = context.frames[0];
+            const context = new contexts.Eval(this.context, utils.copyArray(this.context.frames));
+            const importParent = context.frames[0];
 
             this.importCount++;
             if (importNode.isVariableImport()) {
@@ -53,8 +53,8 @@ ImportVisitor.prototype = {
         visitArgs.visitDeeper = false;
     },
     processImportNode: function(importNode, context, importParent) {
-        var evaldImportNode,
-            inlineCSS = importNode.options.inline;
+        let evaldImportNode;
+        const inlineCSS = importNode.options.inline;
 
         try {
             evaldImportNode = importNode.evalForImport(context);
@@ -67,23 +67,22 @@ ImportVisitor.prototype = {
         }
 
         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;
+            const tryAppendLessExtension = evaldImportNode.css === undefined;
 
-            for (var i = 0; i < importParent.rules.length; i++) {
+            for (let 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);
+            const onImported = this.onImported.bind(this, evaldImportNode, context);
+            const sequencedOnImported = this._sequencer.addImport(onImported);
 
             this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.fileInfo(),
                 evaldImportNode.options, sequencedOnImported);
@@ -102,17 +101,17 @@ ImportVisitor.prototype = {
             this.error = e;
         }
 
-        var importVisitor = this,
-            inlineCSS = importNode.options.inline,
-            isPlugin = importNode.options.isPlugin,
-            isOptional = importNode.options.optional,
-            duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
+        const importVisitor = this;
+        const inlineCSS = importNode.options.inline;
+        const isPlugin = importNode.options.isPlugin;
+        const isOptional = importNode.options.optional;
+        const duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
 
         if (!context.importMultiple) {
             if (duplicateImport) {
                 importNode.skip = true;
             } else {
-                importNode.skip = function() {
+                importNode.skip = () => {
                     if (fullPath in importVisitor.onceFileDetectionMap) {
                         return true;
                     }
@@ -133,7 +132,7 @@ ImportVisitor.prototype = {
             if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {
                 importVisitor.recursionDetector[fullPath] = true;
 
-                var oldContext = this.context;
+                const oldContext = this.context;
                 this.context = context;
                 try {
                     this._visitor.visit(root);
@@ -187,4 +186,4 @@ ImportVisitor.prototype = {
         this.context.frames.shift();
     }
 };
-module.exports = ImportVisitor;
+export default ImportVisitor;