less 4.5.1 → 4.6.0

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

@@ -1,134 +1,149 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
 /* eslint-disable no-unused-vars */
 /**
  * @todo - Remove unused when JSDoc types are added for visitor methods
  */
-var tree_1 = tslib_1.__importDefault(require("../tree"));
-var visitor_1 = tslib_1.__importDefault(require("./visitor"));
-var logger_1 = tslib_1.__importDefault(require("../logger"));
-var utils = tslib_1.__importStar(require("../utils"));
+import tree from '../tree/index.js';
+import Visitor from './visitor.js';
+import logger from '../logger.js';
+import * as utils from '../utils.js';
+
 /* jshint loopfunc:true */
-var ExtendFinderVisitor = /** @class */ (function () {
-    function ExtendFinderVisitor() {
-        this._visitor = new visitor_1.default(this);
+
+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;
-    };
-    ExtendFinderVisitor.prototype.visitDeclaration = function (declNode, visitArgs) {
+    }
+
+    visitDeclaration(declNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    ExtendFinderVisitor.prototype.visitMixinDefinition = function (mixinDefinitionNode, visitArgs) {
+    }
+
+    visitMixinDefinition(mixinDefinitionNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    ExtendFinderVisitor.prototype.visitRuleset = function (rulesetNode, visitArgs) {
+    }
+
+    visitRuleset(rulesetNode, visitArgs) {
         if (rulesetNode.root) {
             return;
         }
-        var i;
-        var j;
-        var extend;
-        var allSelectorsExtendList = [];
-        var 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, ruleCnt = rules ? rules.length : 0;
         for (i = 0; i < ruleCnt; i++) {
-            if (rulesetNode.rules[i] instanceof tree_1.default.Extend) {
+            if (rulesetNode.rules[i] instanceof tree.Extend) {
                 allSelectorsExtendList.push(rules[i]);
                 rulesetNode.extendOnEveryPath = true;
             }
         }
+
         // 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], selector = selectorPath[selectorPath.length - 1], selExtendList = selector.extendList;
+
             extendList = selExtendList ? utils.copyArray(selExtendList).concat(allSelectorsExtendList)
                 : allSelectorsExtendList;
+
             if (extendList) {
-                extendList = extendList.map(function (allSelectorsExtend) {
+                extendList = extendList.map(function(allSelectorsExtend) {
                     return allSelectorsExtend.clone();
                 });
             }
+
             for (j = 0; j < extendList.length; j++) {
                 this.foundExtends = true;
                 extend = extendList[j];
                 extend.findSelfSelectors(selectorPath);
                 extend.ruleset = rulesetNode;
-                if (j === 0) {
-                    extend.firstExtendOnThisSelectorPath = true;
-                }
+                if (j === 0) { extend.firstExtendOnThisSelectorPath = true; }
                 this.allExtendsStack[this.allExtendsStack.length - 1].push(extend);
             }
         }
+
         this.contexts.push(rulesetNode.selectors);
-    };
-    ExtendFinderVisitor.prototype.visitRulesetOut = function (rulesetNode) {
+    }
+
+    visitRulesetOut(rulesetNode) {
         if (!rulesetNode.root) {
             this.contexts.length = this.contexts.length - 1;
         }
-    };
-    ExtendFinderVisitor.prototype.visitMedia = function (mediaNode, visitArgs) {
+    }
+
+    visitMedia(mediaNode, visitArgs) {
         mediaNode.allExtends = [];
         this.allExtendsStack.push(mediaNode.allExtends);
-    };
-    ExtendFinderVisitor.prototype.visitMediaOut = function (mediaNode) {
+    }
+
+    visitMediaOut(mediaNode) {
         this.allExtendsStack.length = this.allExtendsStack.length - 1;
-    };
-    ExtendFinderVisitor.prototype.visitAtRule = function (atRuleNode, visitArgs) {
+    }
+
+    visitAtRule(atRuleNode, visitArgs) {
         atRuleNode.allExtends = [];
         this.allExtendsStack.push(atRuleNode.allExtends);
-    };
-    ExtendFinderVisitor.prototype.visitAtRuleOut = function (atRuleNode) {
+    }
+
+    visitAtRuleOut(atRuleNode) {
         this.allExtendsStack.length = this.allExtendsStack.length - 1;
-    };
-    return ExtendFinderVisitor;
-}());
-var ProcessExtendsVisitor = /** @class */ (function () {
-    function ProcessExtendsVisitor() {
-        this._visitor = new visitor_1.default(this);
     }
-    ProcessExtendsVisitor.prototype.run = function (root) {
-        var extendFinder = new ExtendFinderVisitor();
+}
+
+class ProcessExtendsVisitor {
+    constructor() {
+        this._visitor = new Visitor(this);
+    }
+
+    run(root) {
+        const extendFinder = new ExtendFinderVisitor();
         this.extendIndices = {};
         extendFinder.run(root);
-        if (!extendFinder.foundExtends) {
-            return 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;
-    };
-    ProcessExtendsVisitor.prototype.checkExtendsForNonMatched = function (extendList) {
-        var indices = this.extendIndices;
-        extendList.filter(function (extend) {
+    }
+
+    checkExtendsForNonMatched(extendList) {
+        const indices = this.extendIndices;
+        extendList.filter(function(extend) {
             return !extend.hasFoundMatches && extend.parent_ids.length == 1;
-        }).forEach(function (extend) {
-            var selector = '_unknown_';
+        }).forEach(function(extend) {
+            let selector = '_unknown_';
             try {
                 selector = extend.selector.toCSS({});
             }
-            catch (_) { }
-            if (!indices["".concat(extend.index, " ").concat(selector)]) {
-                indices["".concat(extend.index, " ").concat(selector)] = true;
+            catch (_) {}
+
+            if (!indices[`${extend.index} ${selector}`]) {
+                indices[`${extend.index} ${selector}`] = true;
                 /**
                  * @todo Shouldn't this be an error? To alert the developer
                  * that they may have made an error in the selector they are
                  * targeting?
                  */
-                logger_1.default.warn("WARNING: extend '".concat(selector, "' has no matches"));
+                logger.warn(`WARNING: extend '${selector}' has no matches`);
             }
         });
-    };
-    ProcessExtendsVisitor.prototype.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
@@ -137,17 +152,21 @@ var ProcessExtendsVisitor = /** @class */ (function () {
         // this method deals with all the chaining work - without it, extend is flat and doesn't work on other extend selectors
         // 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;
-        var targetExtendIndex;
-        var matches;
-        var extendsToAdd = [];
-        var newSelector;
-        var extendVisitor = this;
-        var selectorPath;
-        var extend;
-        var targetExtend;
-        var 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;
+
         // loop through comparing every extend with every target extend.
         // a target extend is the one on the ruleset we are looking at copy/edit/pasting in place
         // e.g.  .a:extend(.b) {}  and .b:extend(.c) {} then the first extend extends the second one
@@ -156,32 +175,41 @@ var ProcessExtendsVisitor = /** @class */ (function () {
         // case when processing media queries
         for (extendIndex = 0; extendIndex < extendsList.length; extendIndex++) {
             for (targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++) {
+
                 extend = extendsList[extendIndex];
                 targetExtend = extendsListTarget[targetExtendIndex];
+
                 // look for circular references
-                if (extend.parent_ids.indexOf(targetExtend.object_id) >= 0) {
-                    continue;
-                }
+                if ( extend.parent_ids.indexOf( targetExtend.object_id ) >= 0 ) { continue; }
+
                 // find a match in the target extends self selector (the bit before :extend)
                 selectorPath = [targetExtend.selfSelectors[0]];
                 matches = extendVisitor.findMatch(extend, selectorPath);
+
                 if (matches.length) {
                     extend.hasFoundMatches = true;
+
                     // we found a match, so for each self selector..
-                    extend.selfSelectors.forEach(function (selfSelector) {
-                        var info = targetExtend.visibilityInfo();
+                    extend.selfSelectors.forEach(function(selfSelector) {
+                        const info = targetExtend.visibilityInfo();
+
                         // process the extend as usual
                         newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector, extend.isVisible());
+
                         // but now we create a new extend from it
-                        newExtend = new (tree_1.default.Extend)(targetExtend.selector, targetExtend.option, 0, targetExtend.fileInfo(), info);
+                        newExtend = new(tree.Extend)(targetExtend.selector, targetExtend.option, 0, targetExtend.fileInfo(), info);
                         newExtend.selfSelectors = newSelector;
+
                         // add the extend onto the list of extends for that selector
                         newSelector[newSelector.length - 1].extendList = [newExtend];
+
                         // record that we need to add it.
                         extendsToAdd.push(newExtend);
                         newExtend.ruleset = targetExtend.ruleset;
+
                         // remember its parents for circular references
                         newExtend.parent_ids = newExtend.parent_ids.concat(targetExtend.parent_ids, extend.parent_ids);
+
                         // only process the selector once.. if we have :extend(.a,.b) then multiple
                         // extends will look at the same selector path, so when extending
                         // we know that any others will be duplicates in terms of what is added to the css
@@ -193,101 +221,114 @@ var ProcessExtendsVisitor = /** @class */ (function () {
                 }
             }
         }
+
         if (extendsToAdd.length) {
             // try to detect circular references to stop a stack overflow.
             // 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:".concat(selectorOne, ":extend(").concat(selectorTwo, ")") };
+                catch (e) {}
+                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
             // d extending e...
             return extendsToAdd.concat(extendVisitor.doExtendChaining(extendsToAdd, extendsListTarget, iterationCount + 1));
-        }
-        else {
+        } else {
             return extendsToAdd;
         }
-    };
-    ProcessExtendsVisitor.prototype.visitDeclaration = function (ruleNode, visitArgs) {
+    }
+
+    visitDeclaration(ruleNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    ProcessExtendsVisitor.prototype.visitMixinDefinition = function (mixinDefinitionNode, visitArgs) {
+    }
+
+    visitMixinDefinition(mixinDefinitionNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    ProcessExtendsVisitor.prototype.visitSelector = function (selectorNode, visitArgs) {
+    }
+
+    visitSelector(selectorNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    ProcessExtendsVisitor.prototype.visitRuleset = function (rulesetNode, visitArgs) {
+    }
+
+    visitRuleset(rulesetNode, visitArgs) {
         if (rulesetNode.root) {
             return;
         }
-        var matches;
-        var pathIndex;
-        var extendIndex;
-        var allExtends = this.allExtendsStack[this.allExtendsStack.length - 1];
-        var selectorsToAdd = [];
-        var extendVisitor = this;
-        var selectorPath;
+        let matches;
+        const allExtends = this.allExtendsStack[this.allExtendsStack.length - 1];
+        const selectorsToAdd = [];
+        const paths = rulesetNode.paths;
+        const pathCount = paths.length;
+
         // look at each selector path in the ruleset, find any extend matches and then copy, find and replace
-        for (extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
-            for (pathIndex = 0; pathIndex < rulesetNode.paths.length; pathIndex++) {
-                selectorPath = rulesetNode.paths[pathIndex];
+
+        for (let extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
+            const extend = allExtends[extendIndex];
+            for (let pathIndex = 0; pathIndex < pathCount; pathIndex++) {
+                const selectorPath = paths[pathIndex];
+
                 // extending extends happens initially, before the main pass
-                if (rulesetNode.extendOnEveryPath) {
-                    continue;
-                }
-                var extendList = selectorPath[selectorPath.length - 1].extendList;
-                if (extendList && extendList.length) {
-                    continue;
-                }
-                matches = this.findMatch(allExtends[extendIndex], selectorPath);
+                if (rulesetNode.extendOnEveryPath) { continue; }
+                const extendList = selectorPath[selectorPath.length - 1].extendList;
+                if (extendList && extendList.length) { continue; }
+
+                matches = this.findMatch(extend, selectorPath);
+
                 if (matches.length) {
-                    allExtends[extendIndex].hasFoundMatches = true;
-                    allExtends[extendIndex].selfSelectors.forEach(function (selfSelector) {
-                        var extendedSelectors;
-                        extendedSelectors = extendVisitor.extendSelector(matches, selectorPath, selfSelector, allExtends[extendIndex].isVisible());
-                        selectorsToAdd.push(extendedSelectors);
-                    });
+                    extend.hasFoundMatches = true;
+
+                    const selfSelectors = extend.selfSelectors;
+                    const isVisible = extend.isVisible();
+                    for (let si = 0; si < selfSelectors.length; si++) {
+                        selectorsToAdd.push(this.extendSelector(matches, selectorPath, selfSelectors[si], isVisible));
+                    }
                 }
             }
         }
-        rulesetNode.paths = rulesetNode.paths.concat(selectorsToAdd);
-    };
-    ProcessExtendsVisitor.prototype.findMatch = function (extend, haystackSelectorPath) {
+        rulesetNode.paths = paths.concat(selectorsToAdd);
+    }
+
+    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;
-        var hackstackSelector;
-        var hackstackElementIndex;
-        var haystackElement;
-        var targetCombinator;
-        var i;
-        var extendVisitor = this;
-        var needleElements = extend.selector.elements;
-        var potentialMatches = [];
-        var potentialMatch;
-        var matches = [];
+        let haystackSelectorIndex;
+
+        let hackstackSelector;
+        let hackstackElementIndex;
+        let haystackElement;
+        let targetCombinator;
+        let i;
+        const needleElements = extend.selector.elements;
+        const potentialMatches = [];
+        let potentialMatch;
+        const matches = [];
+
         // loop through the haystack elements
         for (haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
             hackstackSelector = haystackSelectorPath[haystackSelectorIndex];
+
             for (hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {
+
                 haystackElement = hackstackSelector.elements[hackstackElementIndex];
+
                 // if we allow elements before our match we can add a potential match every time. otherwise only at the first element.
                 if (extend.allowBefore || (haystackSelectorIndex === 0 && hackstackElementIndex === 0)) {
-                    potentialMatches.push({ pathIndex: haystackSelectorIndex, index: hackstackElementIndex, matched: 0,
-                        initialCombinator: haystackElement.combinator });
+                    potentialMatches.push({pathIndex: haystackSelectorIndex, index: hackstackElementIndex, matched: 0,
+                        initialCombinator: haystackElement.combinator});
                 }
+
                 for (i = 0; i < potentialMatches.length; i++) {
                     potentialMatch = potentialMatches[i];
+
                     // selectors add " " onto the first element. When we use & it joins the selectors together, but if we don't
                     // then each selector in haystackSelectorPath has a space before it added in the toCSS phase. so we need to
                     // work out what the resulting combinator will be
@@ -295,14 +336,15 @@ var ProcessExtendsVisitor = /** @class */ (function () {
                     if (targetCombinator === '' && hackstackElementIndex === 0) {
                         targetCombinator = ' ';
                     }
+
                     // if we don't match, null our match to indicate failure
-                    if (!extendVisitor.isElementValuesEqual(needleElements[potentialMatch.matched].value, haystackElement.value) ||
+                    if (!this.isElementValuesEqual(needleElements[potentialMatch.matched].value, haystackElement.value) ||
                         (potentialMatch.matched > 0 && needleElements[potentialMatch.matched].combinator.value !== targetCombinator)) {
                         potentialMatch = null;
-                    }
-                    else {
+                    } else {
                         potentialMatch.matched++;
                     }
+
                     // if we are still valid and have finished, test whether we have elements after and whether these are allowed
                     if (potentialMatch) {
                         potentialMatch.finished = potentialMatch.matched === needleElements.length;
@@ -321,8 +363,7 @@ var ProcessExtendsVisitor = /** @class */ (function () {
                             potentialMatches.length = 0; // we don't allow matches to overlap, so start matching again
                             matches.push(potentialMatch);
                         }
-                    }
-                    else {
+                    } else {
                         potentialMatches.splice(i, 1);
                         i--;
                     }
@@ -330,12 +371,13 @@ var ProcessExtendsVisitor = /** @class */ (function () {
             }
         }
         return matches;
-    };
-    ProcessExtendsVisitor.prototype.isElementValuesEqual = function (elementValue1, elementValue2) {
+    }
+
+    isElementValuesEqual(elementValue1, elementValue2) {
         if (typeof elementValue1 === 'string' || typeof elementValue2 === 'string') {
             return elementValue1 === elementValue2;
         }
-        if (elementValue1 instanceof tree_1.default.Attribute) {
+        if (elementValue1 instanceof tree.Attribute) {
             if (elementValue1.op !== elementValue2.op || elementValue1.key !== elementValue2.key) {
                 return false;
             }
@@ -351,11 +393,11 @@ var ProcessExtendsVisitor = /** @class */ (function () {
         }
         elementValue1 = elementValue1.value;
         elementValue2 = elementValue2.value;
-        if (elementValue1 instanceof tree_1.default.Selector) {
-            if (!(elementValue2 instanceof tree_1.default.Selector) || elementValue1.elements.length !== elementValue2.elements.length) {
+        if (elementValue1 instanceof tree.Selector) {
+            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;
@@ -368,31 +410,46 @@ var ProcessExtendsVisitor = /** @class */ (function () {
             return true;
         }
         return false;
-    };
-    ProcessExtendsVisitor.prototype.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, currentSelectorPathElementIndex = 0, path = [], matchIndex, selector, firstElement, match, newElements;
+
         for (matchIndex = 0; matchIndex < matches.length; matchIndex++) {
             match = matches[matchIndex];
             selector = selectorPath[match.pathIndex];
-            firstElement = new tree_1.default.Element(match.initialCombinator, replacementSelector.elements[0].value, replacementSelector.elements[0].isVariable, replacementSelector.elements[0].getIndex(), replacementSelector.elements[0].fileInfo());
+            firstElement = new tree.Element(
+                match.initialCombinator,
+                replacementSelector.elements[0].value,
+                replacementSelector.elements[0].isVariable,
+                replacementSelector.elements[0].getIndex(),
+                replacementSelector.elements[0].fileInfo()
+            );
+
             if (match.pathIndex > currentSelectorPathIndex && currentSelectorPathElementIndex > 0) {
                 path[path.length - 1].elements = path[path.length - 1]
                     .elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
                 currentSelectorPathElementIndex = 0;
                 currentSelectorPathIndex++;
             }
+
             newElements = selector.elements
                 .slice(currentSelectorPathElementIndex, match.index)
                 .concat([firstElement])
                 .concat(replacementSelector.elements.slice(1));
+
             if (currentSelectorPathIndex === match.pathIndex && matchIndex > 0) {
                 path[path.length - 1].elements =
                     path[path.length - 1].elements.concat(newElements);
-            }
-            else {
+            } else {
                 path = path.concat(selectorPath.slice(currentSelectorPathIndex, match.pathIndex));
-                path.push(new tree_1.default.Selector(newElements));
+
+                path.push(new tree.Selector(
+                    newElements
+                ));
             }
             currentSelectorPathIndex = match.endPathIndex;
             currentSelectorPathElementIndex = match.endPathElementIndex;
@@ -401,44 +458,48 @@ var ProcessExtendsVisitor = /** @class */ (function () {
                 currentSelectorPathIndex++;
             }
         }
+
         if (currentSelectorPathIndex < selectorPath.length && currentSelectorPathElementIndex > 0) {
             path[path.length - 1].elements = path[path.length - 1]
                 .elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
             currentSelectorPathIndex++;
         }
+
         path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));
         path = path.map(function (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 {
+            } else {
                 derived.ensureInvisibility();
             }
             return derived;
         });
         return path;
-    };
-    ProcessExtendsVisitor.prototype.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);
-    };
-    ProcessExtendsVisitor.prototype.visitMediaOut = function (mediaNode) {
-        var lastIndex = this.allExtendsStack.length - 1;
+    }
+
+    visitMediaOut(mediaNode) {
+        const lastIndex = this.allExtendsStack.length - 1;
         this.allExtendsStack.length = lastIndex;
-    };
-    ProcessExtendsVisitor.prototype.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);
-    };
-    ProcessExtendsVisitor.prototype.visitAtRuleOut = function (atRuleNode) {
-        var lastIndex = this.allExtendsStack.length - 1;
+    }
+
+    visitAtRuleOut(atRuleNode) {
+        const lastIndex = this.allExtendsStack.length - 1;
         this.allExtendsStack.length = lastIndex;
-    };
-    return ProcessExtendsVisitor;
-}());
-exports.default = ProcessExtendsVisitor;
-//# sourceMappingURL=extend-visitor.js.map
+    }
+}
+
+export default ProcessExtendsVisitor;