less 3.9.0 → 3.10.1

package/lib/less/visitors/index.js

@@ -1,10 +1,15 @@
-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')
-};
+import Visitor from './visitor';
+import ImportVisitor from './import-visitor';
+import MarkVisibleSelectorsVisitor from './set-tree-visibility-visitor';
+import ExtendVisitor from './extend-visitor';
+import JoinSelectorVisitor from './join-selector-visitor';
+import ToCSSVisitor from './to-css-visitor';
 
-module.exports = visitors;
+export default {
+    Visitor,
+    ImportVisitor,
+    MarkVisibleSelectorsVisitor,
+    ExtendVisitor,
+    JoinSelectorVisitor,
+    ToCSSVisitor
+};

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

@@ -1,51 +1,57 @@
-var Visitor = require('./visitor');
+import Visitor from './visitor';
 
-var JoinSelectorVisitor = function() {
-    this.contexts = [[]];
-    this._visitor = new Visitor(this);
-};
+class JoinSelectorVisitor {
+    constructor() {
+        this.contexts = [[]];
+        this._visitor = new Visitor(this);
+    }
 
-JoinSelectorVisitor.prototype = {
-    run: function (root) {
+    run(root) {
         return this._visitor.visit(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) {
-        var context = this.contexts[this.contexts.length - 1],
-            paths = [], selectors;
+    visitRuleset(rulesetNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
+        const paths = [];
+        let selectors;
 
         this.contexts.push(paths);
 
         if (!rulesetNode.root) {
             selectors = rulesetNode.selectors;
             if (selectors) {
-                selectors = selectors.filter(function(selector) { return selector.getIsOutput(); });
+                selectors = selectors.filter(selector => 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) {
+    }
+
+    visitRulesetOut(rulesetNode) {
         this.contexts.length = this.contexts.length - 1;
-    },
-    visitMedia: function (mediaNode, visitArgs) {
-        var context = this.contexts[this.contexts.length - 1];
+    }
+
+    visitMedia(mediaNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
         mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);
-    },
-    visitAtRule: function (atRuleNode, visitArgs) {
-        var context = this.contexts[this.contexts.length - 1];
+    }
+
+    visitAtRule(atRuleNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
         if (atRuleNode.rules && atRuleNode.rules.length) {
             atRuleNode.rules[0].root = (atRuleNode.isRooted || context.length === 0 || null);
         }
     }
-};
+}
 
-module.exports = JoinSelectorVisitor;
+export default JoinSelectorVisitor;

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

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

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

@@ -1,18 +1,18 @@
-var tree = require('../tree'),
-    Visitor = require('./visitor');
+import tree from '../tree';
+import Visitor from './visitor';
 
-var CSSVisitorUtils = function(context) {
-    this._visitor = new Visitor(this);
-    this._context = context;
-};
+class CSSVisitorUtils {
+    constructor(context) {
+        this._visitor = new Visitor(this);
+        this._context = context;
+    }
 
-CSSVisitorUtils.prototype = {
-    containsSilentNonBlockedChild: function(bodyRules) {
-        var rule;
+    containsSilentNonBlockedChild(bodyRules) {
+        let rule;
         if (!bodyRules) {
             return false;
         }
-        for (var r = 0; r < bodyRules.length; r++) {
+        for (let r = 0; r < bodyRules.length; r++) {
             rule = bodyRules[r];
             if (rule.isSilent && rule.isSilent(this._context) && !rule.blocksVisibility()) {
                 // the atrule contains something that was referenced (likely by extend)
@@ -21,27 +21,25 @@ CSSVisitorUtils.prototype = {
             }
         }
         return false;
-    },
+    }
 
-    keepOnlyVisibleChilds: function(owner) {
+    keepOnlyVisibleChilds(owner) {
         if (owner && owner.rules) {
-            owner.rules = owner.rules.filter(function(thing) {
-                return thing.isVisible();
-            });
+            owner.rules = owner.rules.filter(thing => thing.isVisible());
         }
-    },
+    }
 
-    isEmpty: function(owner) {
+    isEmpty(owner) {
         return (owner && owner.rules) 
             ? (owner.rules.length === 0) : true;
-    },
+    }
 
-    hasVisibleSelector: function(rulesetNode) {
+    hasVisibleSelector(rulesetNode) {
         return (rulesetNode && rulesetNode.paths)
             ? (rulesetNode.paths.length > 0) : false;
-    },
+    }
 
-    resolveVisibility: function (node, originalRules) {
+    resolveVisibility(node, originalRules) {
         if (!node.blocksVisibility()) {
             if (this.isEmpty(node) && !this.containsSilentNonBlockedChild(originalRules)) {
                 return ;
@@ -50,7 +48,7 @@ CSSVisitorUtils.prototype = {
             return node;
         }
 
-        var compiledRulesBody = node.rules[0];
+        const compiledRulesBody = node.rules[0];
         this.keepOnlyVisibleChilds(compiledRulesBody);
 
         if (this.isEmpty(compiledRulesBody)) {
@@ -61,9 +59,9 @@ CSSVisitorUtils.prototype = {
         node.removeVisibilityBlock();
 
         return node;
-    },
+    }
 
-    isVisibleRuleset: function(rulesetNode) {
+    isVisibleRuleset(rulesetNode) {
         if (rulesetNode.firstRoot) {
             return true;
         }
@@ -78,10 +76,9 @@ CSSVisitorUtils.prototype = {
 
         return true;
     }
+}
 
-};
-
-var ToCSSVisitor = function(context) {
+const ToCSSVisitor = function(context) {
     this._visitor = new Visitor(this);
     this._context = context;
     this.utils = new CSSVisitorUtils(context);
@@ -117,7 +114,7 @@ ToCSSVisitor.prototype = {
     },
 
     visitMedia: function(mediaNode, visitArgs) {
-        var originalRules = mediaNode.rules[0].rules;
+        const originalRules = mediaNode.rules[0].rules;
         mediaNode.accept(this._visitor);
         visitArgs.visitDeeper = false;
 
@@ -150,11 +147,11 @@ ToCSSVisitor.prototype = {
         // if there is only one nested ruleset and that one has no path, then it is
         // just fake ruleset
         function hasFakeRuleset(atRuleNode) {
-            var bodyRules = atRuleNode.rules;
+            const bodyRules = atRuleNode.rules;
             return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);
         }
         function getBodyRules(atRuleNode) {
-            var nodeRules = atRuleNode.rules;
+            const nodeRules = atRuleNode.rules;
             if (hasFakeRuleset(atRuleNode)) {
                 return nodeRules[0].rules;
             }
@@ -164,7 +161,7 @@ ToCSSVisitor.prototype = {
         // it is still true that it is only one ruleset in array
         // this is last such moment
         // process childs
-        var originalRules = getBodyRules(atRuleNode);
+        const originalRules = getBodyRules(atRuleNode);
         atRuleNode.accept(this._visitor);
         visitArgs.visitDeeper = false;
 
@@ -186,7 +183,7 @@ ToCSSVisitor.prototype = {
             // be considered illegal css as it has to be on the first line
             if (this.charset) {
                 if (atRuleNode.debugInfo) {
-                    var comment = new tree.Comment('/* ' + atRuleNode.toCSS(this._context).replace(/\n/g, '') + ' */\n');
+                    const comment = new tree.Comment(`/* ${atRuleNode.toCSS(this._context).replace(/\n/g, '')} */\n`);
                     comment.debugInfo = atRuleNode.debugInfo;
                     return this._visitor.visit(comment);
                 }
@@ -203,18 +200,18 @@ ToCSSVisitor.prototype = {
             return;
         }
 
-        for (var i = 0; i < rules.length; i++) {
-            var ruleNode = rules[i];
+        for (let i = 0; i < rules.length; i++) {
+            const ruleNode = rules[i];
             if (isRoot && ruleNode instanceof tree.Declaration && !ruleNode.variable) {
                 throw { message: 'Properties must be inside selector blocks. They cannot be in the root',
                     index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};
             }
             if (ruleNode instanceof tree.Call) {
-                throw { message: 'Function \'' + ruleNode.name + '\' is undefined',
+                throw { message: `Function '${ruleNode.name}' is undefined`,
                     index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};
             }
             if (ruleNode.type && !ruleNode.allowRoot) {
-                throw { message: ruleNode.type + ' node returned by a function is not valid here',
+                throw { message: `${ruleNode.type} node returned by a function is not valid here`,
                     index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};
             }
         }
@@ -222,7 +219,9 @@ ToCSSVisitor.prototype = {
 
     visitRuleset: function (rulesetNode, visitArgs) {
         // at this point rulesets are nested into each other
-        var rule, rulesets = [];
+        let rule;
+
+        const rulesets = [];
 
         this.checkValidNodes(rulesetNode.rules, rulesetNode.firstRoot);
 
@@ -231,8 +230,10 @@ ToCSSVisitor.prototype = {
             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; ) {
+            const nodeRules = rulesetNode.rules;
+
+            let nodeRuleCnt = nodeRules ? nodeRules.length : 0;
+            for (let i = 0; i < nodeRuleCnt; ) {
                 rule = nodeRules[i];
                 if (rule && rule.rules) {
                     // visit because we are moving them out from being a child
@@ -252,7 +253,6 @@ ToCSSVisitor.prototype = {
                 rulesetNode.rules = null;
             }
             visitArgs.visitDeeper = false;
-
         } else { // if (! rulesetNode.root) {
             rulesetNode.accept(this._visitor);
             visitArgs.visitDeeper = false;
@@ -278,8 +278,8 @@ ToCSSVisitor.prototype = {
     _compileRulesetPaths: function(rulesetNode) {
         if (rulesetNode.paths) {
             rulesetNode.paths = rulesetNode.paths
-                .filter(function(p) {
-                    var i;
+                .filter(p => {
+                    let i;
                     if (p[0].elements[0].combinator.value === ' ') {
                         p[0].elements[0].combinator = new(tree.Combinator)('');
                     }
@@ -297,8 +297,11 @@ ToCSSVisitor.prototype = {
         if (!rules) { return; }
 
         // remove duplicates
-        var ruleCache = {},
-            ruleList, rule, i;
+        const ruleCache = {};
+
+        let ruleList;
+        let rule;
+        let i;
 
         for (i = rules.length - 1; i >= 0 ; i--) {
             rule = rules[i];
@@ -310,7 +313,7 @@ ToCSSVisitor.prototype = {
                     if (ruleList instanceof tree.Declaration) {
                         ruleList = ruleCache[rule.name] = [ruleCache[rule.name].toCSS(this._context)];
                     }
-                    var ruleCSS = rule.toCSS(this._context);
+                    const ruleCSS = rule.toCSS(this._context);
                     if (ruleList.indexOf(ruleCSS) !== -1) {
                         rules.splice(i, 1);
                     } else {
@@ -326,25 +329,25 @@ ToCSSVisitor.prototype = {
             return; 
         }
 
-        var groups    = {},
-            groupsArr = [];
-        
-        for (var i = 0; i < rules.length; i++) {
-            var rule = rules[i];
+        const groups    = {};
+        const groupsArr = [];
+
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
             if (rule.merge) {
-                var key = rule.name;
+                const key = rule.name;
                 groups[key] ? rules.splice(i--, 1) : 
                     groupsArr.push(groups[key] = []);
                 groups[key].push(rule);
             }
         }
 
-        groupsArr.forEach(function(group) {
+        groupsArr.forEach(group => {
             if (group.length > 0) {
-                var result = group[0],
-                    space  = [],
-                    comma  = [new tree.Expression(space)];
-                group.forEach(function(rule) {
+                const result = group[0];
+                let space  = [];
+                const comma  = [new tree.Expression(space)];
+                group.forEach(rule => {
                     if ((rule.merge === '+') && (space.length > 0)) {
                         comma.push(new tree.Expression(space = []));
                     }
@@ -357,4 +360,4 @@ ToCSSVisitor.prototype = {
     }
 };
 
-module.exports = ToCSSVisitor;
+export default ToCSSVisitor;

package/lib/less/visitors/visitor.js

@@ -1,7 +1,6 @@
-var tree = require('../tree');
-
-var _visitArgs = { visitDeeper: true },
-    _hasIndexed = false;
+import tree from '../tree';
+const _visitArgs = { visitDeeper: true };
+let _hasIndexed = false;
 
 function _noop(node) {
     return node;
@@ -9,7 +8,9 @@ function _noop(node) {
 
 function indexNodeTypes(parent, ticker) {
     // add .typeIndex to tree node types for lookup table
-    var key, child;
+    let key;
+
+    let child;
     for (key in parent) { 
         /* eslint guard-for-in: 0 */
         child = parent[key];
@@ -30,24 +31,24 @@ function indexNodeTypes(parent, ticker) {
     return ticker;
 }
 
-var Visitor = function(implementation) {
-    this._implementation = implementation;
-    this._visitInCache = {};
-    this._visitOutCache = {};
+class Visitor {
+    constructor(implementation) {
+        this._implementation = implementation;
+        this._visitInCache = {};
+        this._visitOutCache = {};
 
-    if (!_hasIndexed) {
-        indexNodeTypes(tree, 1);
-        _hasIndexed = true;
+        if (!_hasIndexed) {
+            indexNodeTypes(tree, 1);
+            _hasIndexed = true;
+        }
     }
-};
 
-Visitor.prototype = {
-    visit: function(node) {
+    visit(node) {
         if (!node) {
             return node;
         }
 
-        var nodeTypeIndex = node.typeIndex;
+        const nodeTypeIndex = node.typeIndex;
         if (!nodeTypeIndex) {
             // MixinCall args aren't a node type?
             if (node.value && node.value.typeIndex) {
@@ -56,24 +57,24 @@ Visitor.prototype = {
             return node;
         }
 
-        var impl = this._implementation,
-            func = this._visitInCache[nodeTypeIndex],
-            funcOut = this._visitOutCache[nodeTypeIndex],
-            visitArgs = _visitArgs,
-            fnName;
+        const impl = this._implementation;
+        let func = this._visitInCache[nodeTypeIndex];
+        let funcOut = this._visitOutCache[nodeTypeIndex];
+        const visitArgs = _visitArgs;
+        let fnName;
 
         visitArgs.visitDeeper = true;
 
         if (!func) {
-            fnName = 'visit' + node.type;
+            fnName = `visit${node.type}`;
             func = impl[fnName] || _noop;
-            funcOut = impl[fnName + 'Out'] || _noop;
+            funcOut = impl[`${fnName}Out`] || _noop;
             this._visitInCache[nodeTypeIndex] = func;
             this._visitOutCache[nodeTypeIndex] = funcOut;
         }
 
         if (func !== _noop) {
-            var newNode = func.call(impl, node, visitArgs);
+            const newNode = func.call(impl, node, visitArgs);
             if (node && impl.isReplacing) {
                 node = newNode;
             }
@@ -88,13 +89,15 @@ Visitor.prototype = {
         }
 
         return node;
-    },
-    visitArray: function(nodes, nonReplacing) {
+    }
+
+    visitArray(nodes, nonReplacing) {
         if (!nodes) {
             return nodes;
         }
 
-        var cnt = nodes.length, i;
+        const cnt = nodes.length;
+        let i;
 
         // Non-replacing
         if (nonReplacing || !this._implementation.isReplacing) {
@@ -105,9 +108,9 @@ Visitor.prototype = {
         }
 
         // Replacing
-        var out = [];
+        const out = [];
         for (i = 0; i < cnt; i++) {
-            var evald = this.visit(nodes[i]);
+            const evald = this.visit(nodes[i]);
             if (evald === undefined) { continue; }
             if (!evald.splice) {
                 out.push(evald);
@@ -116,14 +119,19 @@ Visitor.prototype = {
             }
         }
         return out;
-    },
-    flatten: function(arr, out) {
+    }
+
+    flatten(arr, out) {
         if (!out) {
             out = [];
         }
 
-        var cnt, i, item,
-            nestedCnt, j, nestedItem;
+        let cnt;
+        let i;
+        let item;
+        let nestedCnt;
+        let j;
+        let nestedItem;
 
         for (i = 0, cnt = arr.length; i < cnt; i++) {
             item = arr[i];
@@ -150,5 +158,6 @@ Visitor.prototype = {
 
         return out;
     }
-};
-module.exports = Visitor;
+}
+
+export default Visitor;

package/lib/less-browser/add-default-options.js

@@ -1,7 +1,7 @@
-var addDataAttr = require('./utils').addDataAttr,
-    browser = require('./browser');
+import {addDataAttr} from './utils';
+import browser from './browser';
 
-module.exports = function(window, options) {
+export default (window, options) => {
 
     // use options from the current script tag data attribues
     addDataAttr(options, browser.currentScript(window));
@@ -30,7 +30,7 @@ module.exports = function(window, options) {
         options.isFileProtocol                   ? 'development'
         : 'production');
 
-    var dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(window.location.hash);
+    const dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(window.location.hash);
     if (dumpLineNumbers) {
         options.dumpLineNumbers = dumpLineNumbers[1];
     }

package/lib/less-browser/bootstrap.js

@@ -5,21 +5,20 @@
  */
 /* global window, document */
 
-// TODO - consider switching this out for a recommendation for this polyfill?
-// <script src="https://cdn.polyfill.io/v2/polyfill.min.js"></script>
-// Browsers have good Promise support
-require('promise/polyfill');
+import defaultOptions from '../less/default-options';
+import addDefaultOptions from './add-default-options';
+import root from './index';
 
-var options = require('../less/default-options')();
+const options = defaultOptions();
 
 if (window.less) {
-    for (key in window.less) {
+    for (const key in window.less) {
         if (window.less.hasOwnProperty(key)) {
             options[key] = window.less[key];
         }
     }
 }
-require('./add-default-options')(window, options);
+addDefaultOptions(window, options);
 
 options.plugins = options.plugins || [];
 
@@ -27,11 +26,14 @@ if (window.LESS_PLUGINS) {
     options.plugins = options.plugins.concat(window.LESS_PLUGINS);
 }
 
-var less = module.exports = require('./index')(window, options);
+const less = root(window, options);
+export default less;
 
 window.less = less;
 
-var css, head, style;
+let css;
+let head;
+let style;
 
 // Always restore page visibility
 function resolveOrReject(data) {