less 3.9.0 → 3.10.1

package/lib/less/tree/import.js

@@ -1,11 +1,11 @@
-var Node = require('./node'),
-    Media = require('./media'),
-    URL = require('./url'),
-    Quoted = require('./quoted'),
-    Ruleset = require('./ruleset'),
-    Anonymous = require('./anonymous'),
-    utils = require('../utils'),
-    LessError = require('../less-error');
+import Node from './node';
+import Media from './media';
+import URL from './url';
+import Quoted from './quoted';
+import Ruleset from './ruleset';
+import Anonymous from './anonymous';
+import * as utils from '../utils';
+import LessError from '../less-error';
 
 //
 // CSS @import node
@@ -19,163 +19,166 @@ var Node = require('./node'),
 // `import,push`, we also pass it a callback, which it'll call once
 // the file has been fetched, and parsed.
 //
-var Import = function (path, features, options, index, currentFileInfo, visibilityInfo) {
-    this.options = options;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.path = path;
-    this.features = features;
-    this.allowRoot = true;
-
-    if (this.options.less !== undefined || this.options.inline) {
-        this.css = !this.options.less || this.options.inline;
-    } else {
-        var pathValue = this.getPath();
-        if (pathValue && /[#\.\&\?]css([\?;].*)?$/.test(pathValue)) {
-            this.css = true;
+class Import extends Node {
+    constructor(path, features, options, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.options = options;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.path = path;
+        this.features = features;
+        this.allowRoot = true;
+
+        if (this.options.less !== undefined || this.options.inline) {
+            this.css = !this.options.less || this.options.inline;
+        } else {
+            const pathValue = this.getPath();
+            if (pathValue && /[#\.\&\?]css([\?;].*)?$/.test(pathValue)) {
+                this.css = true;
+            }
         }
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.features, this);
+        this.setParent(this.path, this);
     }
-    this.copyVisibilityInfo(visibilityInfo);
-    this.setParent(this.features, this);
-    this.setParent(this.path, this);
-};
 
-//
-// The actual import node doesn't return anything, when converted to CSS.
-// The reason is that it's used at the evaluation stage, so that the rules
-// it imports can be treated like any other rules.
-//
-// In `eval`, we make sure all Import nodes get evaluated, recursively, so
-// we end up with a flat structure, which can easily be imported in the parent
-// ruleset.
-//
-Import.prototype = new Node();
-Import.prototype.type = 'Import';
-Import.prototype.accept = function (visitor) {
-    if (this.features) {
-        this.features = visitor.visit(this.features);
-    }
-    this.path = visitor.visit(this.path);
-    if (!this.options.isPlugin && !this.options.inline && this.root) {
-        this.root = visitor.visit(this.root);
-    }
-};
-Import.prototype.genCSS = function (context, output) {
-    if (this.css && this.path._fileInfo.reference === undefined) {
-        output.add('@import ', this._fileInfo, this._index);
-        this.path.genCSS(context, output);
+    accept(visitor) {
         if (this.features) {
-            output.add(' ');
-            this.features.genCSS(context, output);
+            this.features = visitor.visit(this.features);
+        }
+        this.path = visitor.visit(this.path);
+        if (!this.options.isPlugin && !this.options.inline && this.root) {
+            this.root = visitor.visit(this.root);
         }
-        output.add(';');
     }
-};
-Import.prototype.getPath = function () {
-    return (this.path instanceof URL) ?
-        this.path.value.value : this.path.value;
-};
-Import.prototype.isVariableImport = function () {
-    var path = this.path;
-    if (path instanceof URL) {
-        path = path.value;
+
+    genCSS(context, output) {
+        if (this.css && this.path._fileInfo.reference === undefined) {
+            output.add('@import ', this._fileInfo, this._index);
+            this.path.genCSS(context, output);
+            if (this.features) {
+                output.add(' ');
+                this.features.genCSS(context, output);
+            }
+            output.add(';');
+        }
     }
-    if (path instanceof Quoted) {
-        return path.containsVariables();
+
+    getPath() {
+        return (this.path instanceof URL) ?
+            this.path.value.value : this.path.value;
     }
 
-    return true;
-};
-Import.prototype.evalForImport = function (context) {
-    var path = this.path;
+    isVariableImport() {
+        let path = this.path;
+        if (path instanceof URL) {
+            path = path.value;
+        }
+        if (path instanceof Quoted) {
+            return path.containsVariables();
+        }
 
-    if (path instanceof URL) {
-        path = path.value;
+        return true;
     }
 
-    return new Import(path.eval(context), this.features, this.options, this._index, this._fileInfo, this.visibilityInfo());
-};
-Import.prototype.evalPath = function (context) {
-    var path = this.path.eval(context);
-    var fileInfo = this._fileInfo;
-
-    if (!(path instanceof URL)) {
-        // Add the rootpath if the URL requires a rewrite
-        var pathValue = path.value;
-        if (fileInfo &&
-            pathValue &&
-            context.pathRequiresRewrite(pathValue)) {
-            path.value = context.rewritePath(pathValue, fileInfo.rootpath);
-        } else {
-            path.value = context.normalizePath(path.value);
+    evalForImport(context) {
+        let path = this.path;
+
+        if (path instanceof URL) {
+            path = path.value;
         }
+
+        return new Import(path.eval(context), this.features, this.options, this._index, this._fileInfo, this.visibilityInfo());
     }
 
-    return path;
-};
-Import.prototype.eval = function (context) {
-    var result = this.doEval(context);
-    if (this.options.reference || this.blocksVisibility()) {
-        if (result.length || result.length === 0) {
-            result.forEach(function (node) {
-                node.addVisibilityBlock();
+    evalPath(context) {
+        const path = this.path.eval(context);
+        const fileInfo = this._fileInfo;
+
+        if (!(path instanceof URL)) {
+            // Add the rootpath if the URL requires a rewrite
+            const pathValue = path.value;
+            if (fileInfo &&
+                pathValue &&
+                context.pathRequiresRewrite(pathValue)) {
+                path.value = context.rewritePath(pathValue, fileInfo.rootpath);
+            } else {
+                path.value = context.normalizePath(path.value);
             }
-            );
-        } else {
-            result.addVisibilityBlock();
         }
+
+        return path;
     }
-    return result;
-};
-Import.prototype.doEval = function (context) {
-    var ruleset, registry,
-        features = this.features && this.features.eval(context);
-
-    if (this.options.isPlugin) {
-        if (this.root && this.root.eval) {
-            try {
-                this.root.eval(context);
-            }
-            catch (e) {
-                e.message = 'Plugin error during evaluation';
-                throw new LessError(e, this.root.imports, this.root.filename);
+
+    eval(context) {
+        const result = this.doEval(context);
+        if (this.options.reference || this.blocksVisibility()) {
+            if (result.length || result.length === 0) {
+                result.forEach(node => {
+                    node.addVisibilityBlock();
+                }
+                );
+            } else {
+                result.addVisibilityBlock();
             }
         }
-        registry = context.frames[0] && context.frames[0].functionRegistry;
-        if ( registry && this.root && this.root.functions ) {
-            registry.addMultiple( this.root.functions );
-        }
-
-        return [];
+        return result;
     }
 
-    if (this.skip) {
-        if (typeof this.skip === 'function') {
-            this.skip = this.skip();
-        }
-        if (this.skip) {
+    doEval(context) {
+        let ruleset;
+        let registry;
+        const features = this.features && this.features.eval(context);
+
+        if (this.options.isPlugin) {
+            if (this.root && this.root.eval) {
+                try {
+                    this.root.eval(context);
+                }
+                catch (e) {
+                    e.message = 'Plugin error during evaluation';
+                    throw new LessError(e, this.root.imports, this.root.filename);
+                }
+            }
+            registry = context.frames[0] && context.frames[0].functionRegistry;
+            if ( registry && this.root && this.root.functions ) {
+                registry.addMultiple( this.root.functions );
+            }
+
             return [];
         }
-    }
-    if (this.options.inline) {
-        var contents = new Anonymous(this.root, 0,
-            {
-                filename: this.importedFilename,
-                reference: this.path._fileInfo && this.path._fileInfo.reference
-            }, true, true);
-
-        return this.features ? new Media([contents], this.features.value) : [contents];
-    } else if (this.css) {
-        var newImport = new Import(this.evalPath(context), features, this.options, this._index);
-        if (!newImport.css && this.error) {
-            throw this.error;
+
+        if (this.skip) {
+            if (typeof this.skip === 'function') {
+                this.skip = this.skip();
+            }
+            if (this.skip) {
+                return [];
+            }
         }
-        return newImport;
-    } else {
-        ruleset = new Ruleset(null, utils.copyArray(this.root.rules));
-        ruleset.evalImports(context);
+        if (this.options.inline) {
+            const contents = new Anonymous(this.root, 0,
+                {
+                    filename: this.importedFilename,
+                    reference: this.path._fileInfo && this.path._fileInfo.reference
+                }, true, true);
 
-        return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;
+            return this.features ? new Media([contents], this.features.value) : [contents];
+        } else if (this.css) {
+            const newImport = new Import(this.evalPath(context), features, this.options, this._index);
+            if (!newImport.css && this.error) {
+                throw this.error;
+            }
+            return newImport;
+        } else {
+            ruleset = new Ruleset(null, utils.copyArray(this.root.rules));
+            ruleset.evalImports(context);
+
+            return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;
+        }
     }
-};
-module.exports = Import;
+}
+
+Import.prototype.type = 'Import';
+export default Import;

package/lib/less/tree/index.js

@@ -1,42 +1,54 @@
-var tree = Object.create(null);
+const tree = Object.create(null);
 
-tree.Node = require('./node');
-tree.Color = require('./color');
-tree.AtRule = require('./atrule');
-tree.DetachedRuleset = require('./detached-ruleset');
-tree.Operation = require('./operation');
-tree.Dimension = require('./dimension');
-tree.Unit = require('./unit');
-tree.Keyword = require('./keyword');
-tree.Variable = require('./variable');
-tree.Property = require('./property');
-tree.Ruleset = require('./ruleset');
-tree.Element = require('./element');
-tree.Attribute = require('./attribute');
-tree.Combinator = require('./combinator');
-tree.Selector = require('./selector');
-tree.Quoted = require('./quoted');
-tree.Expression = require('./expression');
-tree.Declaration = require('./declaration');
-tree.Call = require('./call');
-tree.URL = require('./url');
-tree.Import = require('./import');
-tree.mixin = {
-    Call: require('./mixin-call'),
-    Definition: require('./mixin-definition')
-};
-tree.Comment = require('./comment');
-tree.Anonymous = require('./anonymous');
-tree.Value = require('./value');
-tree.JavaScript = require('./javascript');
-tree.Assignment = require('./assignment');
-tree.Condition = require('./condition');
-tree.Paren = require('./paren');
-tree.Media = require('./media');
-tree.UnicodeDescriptor = require('./unicode-descriptor');
-tree.Negative = require('./negative');
-tree.Extend = require('./extend');
-tree.VariableCall = require('./variable-call');
-tree.NamespaceValue = require('./namespace-value');
+import Node from './node';
+import Color from './color';
+import AtRule from './atrule';
+import DetachedRuleset from './detached-ruleset';
+import Operation from './operation';
+import Dimension from './dimension';
+import Unit from './unit';
+import Keyword from './keyword';
+import Variable from './variable';
+import Property from './property';
+import Ruleset from './ruleset';
+import Element from './element';
+import Attribute from './attribute';
+import Combinator from './combinator';
+import Selector from './selector';
+import Quoted from './quoted';
+import Expression from './expression';
+import Declaration from './declaration';
+import Call from './call';
+import URL from './url';
+import Import from './import';
+import Comment from './comment';
+import Anonymous from './anonymous';
+import Value from './value';
+import JavaScript from './javascript';
+import Assignment from './assignment';
+import Condition from './condition';
+import Paren from './paren';
+import Media from './media';
+import UnicodeDescriptor from './unicode-descriptor';
+import Negative from './negative';
+import Extend from './extend';
+import VariableCall from './variable-call';
+import NamespaceValue from './namespace-value';
 
-module.exports = tree;
+// mixins
+import MixinCall from './mixin-call';
+import MixinDefinition from './mixin-definition';
+
+export default {
+    Node, Color, AtRule, DetachedRuleset, Operation,
+    Dimension, Unit, Keyword, Variable, Property,
+    Ruleset, Element, Attribute, Combinator, Selector,
+    Quoted, Expression, Declaration, Call, URL, Import,
+    Comment, Anonymous, Value, JavaScript, Assignment,
+    Condition, Paren, Media, UnicodeDescriptor, Negative,
+    Extend, VariableCall, NamespaceValue,
+    mixin: {
+        Call: MixinCall,
+        Definition: MixinDefinition
+    }
+};

package/lib/less/tree/javascript.js

@@ -1,29 +1,33 @@
-var JsEvalNode = require('./js-eval-node'),
-    Dimension = require('./dimension'),
-    Quoted = require('./quoted'),
-    Anonymous = require('./anonymous');
+import JsEvalNode from './js-eval-node';
+import Dimension from './dimension';
+import Quoted from './quoted';
+import Anonymous from './anonymous';
 
-var JavaScript = function (string, escaped, index, currentFileInfo) {
-    this.escaped = escaped;
-    this.expression = string;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-JavaScript.prototype = new JsEvalNode();
-JavaScript.prototype.type = 'JavaScript';
-JavaScript.prototype.eval = function(context) {
-    var result = this.evaluateJavaScript(this.expression, context);
-    var type = typeof result;
+class JavaScript extends JsEvalNode {
+    constructor(string, escaped, index, currentFileInfo) {
+        super();
 
-    if (type === 'number' && !isNaN(result)) {
-        return new Dimension(result);
-    } else if (type === 'string') {
-        return new Quoted('"' + result + '"', result, this.escaped, this._index);
-    } else if (Array.isArray(result)) {
-        return new Anonymous(result.join(', '));
-    } else {
-        return new Anonymous(result);
+        this.escaped = escaped;
+        this.expression = string;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
     }
-};
 
-module.exports = JavaScript;
+    eval(context) {
+        const result = this.evaluateJavaScript(this.expression, context);
+        const type = typeof result;
+
+        if (type === 'number' && !isNaN(result)) {
+            return new Dimension(result);
+        } else if (type === 'string') {
+            return new Quoted(`"${result}"`, result, this.escaped, this._index);
+        } else if (Array.isArray(result)) {
+            return new Anonymous(result.join(', '));
+        } else {
+            return new Anonymous(result);
+        }
+    }
+}
+
+JavaScript.prototype.type = 'JavaScript';
+export default JavaScript;

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

@@ -1,61 +1,58 @@
-var Node = require('./node'),
-    Variable = require('./variable');
-
-var JsEvalNode = function() {
-};
-JsEvalNode.prototype = new Node();
-
-JsEvalNode.prototype.evaluateJavaScript = function (expression, context) {
-    var result,
-        that = this,
-        evalContext = {};
-
-    if (!context.javascriptEnabled) {
-        throw { message: 'Inline JavaScript is not enabled. Is it set in your options?',
-            filename: this.fileInfo().filename,
-            index: this.getIndex() };
-    }
+import Node from './node';
+import Variable from './variable';
+
+class JsEvalNode extends Node {
+    evaluateJavaScript(expression, context) {
+        let result;
+        const that = this;
+        const evalContext = {};
+
+        if (!context.javascriptEnabled) {
+            throw { message: 'Inline JavaScript is not enabled. Is it set in your options?',
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
 
-    expression = expression.replace(/@\{([\w-]+)\}/g, function (_, name) {
-        return that.jsify(new Variable('@' + name, that.getIndex(), that.fileInfo()).eval(context));
-    });
+        expression = expression.replace(/@\{([\w-]+)\}/g, (_, name) => that.jsify(new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context)));
 
-    try {
-        expression = new Function('return (' + expression + ')');
-    } catch (e) {
-        throw { message: 'JavaScript evaluation error: ' + e.message + ' from `' + expression + '`' ,
-            filename: this.fileInfo().filename,
-            index: this.getIndex() };
-    }
+        try {
+            expression = new Function(`return (${expression})`);
+        } catch (e) {
+            throw { message: `JavaScript evaluation error: ${e.message} from \`${expression}\`` ,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
 
-    var variables = context.frames[0].variables();
-    for (var k in variables) {
-        if (variables.hasOwnProperty(k)) {
-            /* jshint loopfunc:true */
-            evalContext[k.slice(1)] = {
-                value: variables[k].value,
-                toJS: function () {
-                    return this.value.eval(context).toCSS();
-                }
-            };
+        const variables = context.frames[0].variables();
+        for (const k in variables) {
+            if (variables.hasOwnProperty(k)) {
+                /* jshint loopfunc:true */
+                evalContext[k.slice(1)] = {
+                    value: variables[k].value,
+                    toJS: function () {
+                        return this.value.eval(context).toCSS();
+                    }
+                };
+            }
         }
-    }
 
-    try {
-        result = expression.call(evalContext);
-    } catch (e) {
-        throw { message: 'JavaScript evaluation error: \'' + e.name + ': ' + e.message.replace(/["]/g, '\'') + '\'' ,
-            filename: this.fileInfo().filename,
-            index: this.getIndex() };
+        try {
+            result = expression.call(evalContext);
+        } catch (e) {
+            throw { message: `JavaScript evaluation error: '${e.name}: ${e.message.replace(/["]/g, '\'')}'` ,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+        return result;
     }
-    return result;
-};
-JsEvalNode.prototype.jsify = function (obj) {
-    if (Array.isArray(obj.value) && (obj.value.length > 1)) {
-        return '[' + obj.value.map(function (v) { return v.toCSS(); }).join(', ') + ']';
-    } else {
-        return obj.toCSS();
+
+    jsify(obj) {
+        if (Array.isArray(obj.value) && (obj.value.length > 1)) {
+            return `[${obj.value.map(v => v.toCSS()).join(', ')}]`;
+        } else {
+            return obj.toCSS();
+        }
     }
-};
+}
 
-module.exports = JsEvalNode;
+export default JsEvalNode;

package/lib/less/tree/keyword.js

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