less 4.4.2 → 4.6.0

package/lib/less/parser/parser.js

@@ -1,16 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var less_error_1 = tslib_1.__importDefault(require("../less-error"));
-var tree_1 = tslib_1.__importDefault(require("../tree"));
-var visitors_1 = tslib_1.__importDefault(require("../visitors"));
-var parser_input_1 = tslib_1.__importDefault(require("./parser-input"));
-var utils = tslib_1.__importStar(require("../utils"));
-var function_registry_1 = tslib_1.__importDefault(require("../functions/function-registry"));
-var atrule_syntax_1 = require("../tree/atrule-syntax");
-var logger_1 = tslib_1.__importDefault(require("../logger"));
-var selector_1 = tslib_1.__importDefault(require("../tree/selector"));
-var anonymous_1 = tslib_1.__importDefault(require("../tree/anonymous"));
+import LessError from '../less-error.js';
+import tree from '../tree/index.js';
+import visitors from '../visitors/index.js';
+import getParserInput from './parser-input.js';
+import * as utils from '../utils.js';
+import functionRegistry from '../functions/function-registry.js';
+import { ContainerSyntaxOptions, MediaSyntaxOptions } from '../tree/atrule-syntax.js';
+import logger from '../logger.js';
+import { DeprecationHandler } from '../deprecation.js';
+import Selector from '../tree/selector.js';
+import Anonymous from '../tree/anonymous.js';
+
 //
 // less.js - parser
 //
@@ -43,58 +42,79 @@ var anonymous_1 = tslib_1.__importDefault(require("../tree/anonymous"));
 //    a terminal string or regexp, or a non-terminal function to call.
 //    It also takes care of moving all the indices forwards.
 //
-var Parser = function Parser(context, imports, fileInfo, currentIndex) {
+
+const Parser = function Parser(context, imports, fileInfo, currentIndex) {
     currentIndex = currentIndex || 0;
-    var parsers;
-    var parserInput = (0, parser_input_1.default)();
+    let parsers;
+    const parserInput = getParserInput();
+
     function error(msg, type) {
-        throw new less_error_1.default({
-            index: parserInput.i,
-            filename: fileInfo.filename,
-            type: type || 'Syntax',
-            message: msg
-        }, imports);
+        throw new LessError(
+            {
+                index: parserInput.i,
+                filename: fileInfo.filename,
+                type: type || 'Syntax',
+                message: msg
+            },
+            imports
+        );
     }
+
+    const deprecationHandler = new DeprecationHandler();
+
     /**
-     *
      * @param {string} msg
      * @param {number} index
      * @param {string} type
+     * @param {string} [deprecationId] - stable deprecation ID for repetition limiting
      */
-    function warn(msg, index, type) {
-        if (!context.quiet) {
-            logger_1.default.warn((new less_error_1.default({
-                index: index !== null && index !== void 0 ? index : parserInput.i,
-                filename: fileInfo.filename,
-                type: type ? "".concat(type.toUpperCase(), " WARNING") : 'WARNING',
-                message: msg
-            }, imports)).toString());
-        }
+    function warn(msg, index, type, deprecationId) {
+        if (context.quiet) { return; }
+        if (deprecationId && context.quietDeprecations) { return; }
+        if (deprecationId && !deprecationHandler.shouldWarn(deprecationId)) { return; }
+
+        logger.warn(
+            (new LessError(
+                {
+                    index: index ?? parserInput.i,
+                    filename: fileInfo.filename,
+                    type: type ? `${type.toUpperCase()} WARNING` : 'WARNING',
+                    message: msg
+                },
+                imports
+            )).toString()
+        );
     }
+
     function expect(arg, msg) {
         // some older browsers return typeof 'function' for RegExp
-        var result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
+        const result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
         if (result) {
             return result;
         }
+
         error(msg || (typeof arg === 'string'
-            ? "expected '".concat(arg, "' got '").concat(parserInput.currentChar(), "'")
+            ? `expected '${arg}' got '${parserInput.currentChar()}'`
             : 'unexpected token'));
     }
+
     // Specialization of expect()
     function expectChar(arg, msg) {
         if (parserInput.$char(arg)) {
             return arg;
         }
-        error(msg || "expected '".concat(arg, "' got '").concat(parserInput.currentChar(), "'"));
+        error(msg || `expected '${arg}' got '${parserInput.currentChar()}'`);
     }
+
     function getDebugInfo(index) {
-        var filename = fileInfo.filename;
+        const filename = fileInfo.filename;
+
         return {
             lineNumber: utils.getLocation(index, parserInput.getInput()).line + 1,
             fileName: filename
         };
     }
+
     /**
      *  Used after initial parsing to create nodes on the fly
      *
@@ -104,43 +124,40 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
      *  @param {Object} fileInfo     - fileInfo to attach to created nodes
      */
     function parseNode(str, parseList, callback) {
-        var result;
-        var returnNodes = [];
-        var parser = parserInput;
+        let result;
+        const returnNodes = [];
+        const parser = parserInput;
+
         try {
-            parser.start(str, false, function fail(msg, index) {
-                callback({
-                    message: msg,
-                    index: index + currentIndex
-                });
-            });
-            for (var x = 0, p = void 0; (p = parseList[x]); x++) {
+            parser.start(str);
+            for (let x = 0, p; (p = parseList[x]); x++) {
                 result = parsers[p]();
                 returnNodes.push(result || null);
             }
-            var endInfo = parser.end();
+
+            const endInfo = parser.end();
             if (endInfo.isFinished) {
                 callback(null, returnNodes);
             }
             else {
                 callback(true, null);
             }
-        }
-        catch (e) {
-            throw new less_error_1.default({
+        } catch (e) {
+            throw new LessError({
                 index: e.index + currentIndex,
                 message: e.message
             }, imports, fileInfo.filename);
         }
     }
+
     //
     // The Parser
     //
     return {
-        parserInput: parserInput,
-        imports: imports,
-        fileInfo: fileInfo,
-        parseNode: parseNode,
+        parserInput,
+        imports,
+        fileInfo,
+        parseNode,
         //
         // Parse an input string into an abstract syntax tree,
         // @param str A string containing 'less' markup
@@ -148,62 +165,63 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
         // @param [additionalData] An optional map which can contains vars - a map (key, value) of variables to apply
         //
         parse: function (str, callback, additionalData) {
-            var root;
-            var err = null;
-            var globalVars;
-            var modifyVars;
-            var ignored;
-            var preText = '';
+            let root;
+            let err = null;
+            let globalVars;
+            let modifyVars;
+            let ignored;
+            let preText = '';
+
             // Optionally disable @plugin parsing
             if (additionalData && additionalData.disablePluginRule) {
-                parsers.plugin = function () {
+                parsers.plugin = function() {
                     var dir = parserInput.$re(/^@plugin?\s+/);
                     if (dir) {
                         error('@plugin statements are not allowed when disablePluginRule is set to true');
                     }
-                };
+                }
             }
-            globalVars = (additionalData && additionalData.globalVars) ? "".concat(Parser.serializeVars(additionalData.globalVars), "\n") : '';
-            modifyVars = (additionalData && additionalData.modifyVars) ? "\n".concat(Parser.serializeVars(additionalData.modifyVars)) : '';
+
+            globalVars = (additionalData && additionalData.globalVars) ? `${Parser.serializeVars(additionalData.globalVars)}\n` : '';
+            modifyVars = (additionalData && additionalData.modifyVars) ? `\n${Parser.serializeVars(additionalData.modifyVars)}` : '';
+
             if (context.pluginManager) {
-                var preProcessors = context.pluginManager.getPreProcessors();
-                for (var i = 0; i < preProcessors.length; i++) {
-                    str = preProcessors[i].process(str, { context: context, imports: imports, fileInfo: fileInfo });
+                const preProcessors = context.pluginManager.getPreProcessors();
+                for (let i = 0; i < preProcessors.length; i++) {
+                    str = preProcessors[i].process(str, { context, imports, fileInfo });
                 }
             }
+
             if (globalVars || (additionalData && additionalData.banner)) {
                 preText = ((additionalData && additionalData.banner) ? additionalData.banner : '') + globalVars;
                 ignored = imports.contentsIgnoredChars;
                 ignored[fileInfo.filename] = ignored[fileInfo.filename] || 0;
                 ignored[fileInfo.filename] += preText.length;
             }
+
             str = str.replace(/\r\n?/g, '\n');
             // Remove potential UTF Byte Order Mark
             str = preText + str.replace(/^\uFEFF/, '') + modifyVars;
             imports.contents[fileInfo.filename] = str;
+
             // Start with the primary rule.
             // The whole syntax tree is held under a Ruleset node,
             // with the `root` property set to true, so no `{}` are
             // output. The callback is called when the input is parsed.
             try {
-                parserInput.start(str, context.chunkInput, function fail(msg, index) {
-                    throw new less_error_1.default({
-                        index: index,
-                        type: 'Parse',
-                        message: msg,
-                        filename: fileInfo.filename
-                    }, imports);
-                });
-                tree_1.default.Node.prototype.parse = this;
-                root = new tree_1.default.Ruleset(null, this.parsers.primary());
-                tree_1.default.Node.prototype.rootNode = root;
+                parserInput.start(str);
+
+                tree.Node.prototype.parse = this;
+                root = new tree.Ruleset(null, this.parsers.primary());
+                tree.Node.prototype.rootNode = root;
                 root.root = true;
                 root.firstRoot = true;
-                root.functionRegistry = function_registry_1.default.inherit();
-            }
-            catch (e) {
-                return callback(new less_error_1.default(e, imports, fileInfo.filename));
+                root.functionRegistry = functionRegistry.inherit();
+
+            } catch (e) {
+                return callback(new LessError(e, imports, fileInfo.filename));
             }
+
             // If `i` is smaller than the `input.length - 1`,
             // it means the parser wasn't able to parse the whole
             // string, so we've got a parsing error.
@@ -212,48 +230,53 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // showing the line where the parse error occurred.
             // We split it up into two parts (the part which parsed,
             // and the part which didn't), so we can color them differently.
-            var endInfo = parserInput.end();
+            const endInfo = parserInput.end();
             if (!endInfo.isFinished) {
-                var message = endInfo.furthestPossibleErrorMessage;
+
+                let message = endInfo.furthestPossibleErrorMessage;
+
                 if (!message) {
                     message = 'Unrecognised input';
                     if (endInfo.furthestChar === '}') {
                         message += '. Possibly missing opening \'{\'';
-                    }
-                    else if (endInfo.furthestChar === ')') {
+                    } else if (endInfo.furthestChar === ')') {
                         message += '. Possibly missing opening \'(\'';
-                    }
-                    else if (endInfo.furthestReachedEnd) {
+                    } else if (endInfo.furthestReachedEnd) {
                         message += '. Possibly missing something';
                     }
                 }
-                err = new less_error_1.default({
+
+                err = new LessError({
                     type: 'Parse',
-                    message: message,
+                    message,
                     index: endInfo.furthest,
                     filename: fileInfo.filename
                 }, imports);
             }
-            var finish = function (e) {
+
+            const finish = e => {
                 e = err || e || imports.error;
+
                 if (e) {
-                    if (!(e instanceof less_error_1.default)) {
-                        e = new less_error_1.default(e, imports, fileInfo.filename);
+                    if (!(e instanceof LessError)) {
+                        e = new LessError(e, imports, fileInfo.filename);
                     }
+
                     return callback(e);
                 }
                 else {
                     return callback(null, root);
                 }
             };
+
             if (context.processImports !== false) {
-                new visitors_1.default.ImportVisitor(imports, finish)
+                new visitors.ImportVisitor(imports, finish)
                     .run(root);
-            }
-            else {
+            } else {
                 return finish();
             }
         },
+
         //
         // Here in, the parsing rules/functions
         //
@@ -300,15 +323,14 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // block rule: at the root level.
             //
             primary: function () {
-                var mixin = this.mixin;
-                var root = [];
-                var node;
+                const mixin = this.mixin;
+                let root = [];
+                let node;
+
                 while (true) {
                     while (true) {
                         node = this.comment();
-                        if (!node) {
-                            break;
-                        }
+                        if (!node) { break; }
                         root.push(node);
                     }
                     // always process comments before deciding if finished
@@ -318,18 +340,19 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     if (parserInput.peek('}')) {
                         break;
                     }
+
                     node = this.extendRule();
                     if (node) {
                         root = root.concat(node);
                         continue;
                     }
+
                     node = mixin.definition() || this.declaration() || mixin.call(false, false) ||
                         this.ruleset() || this.variableCall() || this.entities.call() || this.atrule();
                     if (node) {
                         root.push(node);
-                    }
-                    else {
-                        var foundSemiColon = false;
+                    } else {
+                        let foundSemiColon = false;
                         while (parserInput.$char(';')) {
                             foundSemiColon = true;
                         }
@@ -338,21 +361,24 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         }
                     }
                 }
+
                 return root;
             },
+
             // comments are collected by the main parsing mechanism and then assigned to nodes
             // where the current structure allows it
             comment: function () {
                 if (parserInput.commentStore.length) {
-                    var comment = parserInput.commentStore.shift();
-                    return new (tree_1.default.Comment)(comment.text, comment.isLineComment, comment.index + currentIndex, fileInfo);
+                    const comment = parserInput.commentStore.shift();
+                    return new(tree.Comment)(comment.text, comment.isLineComment, comment.index + currentIndex, fileInfo);
                 }
             },
+
             //
             // Entities are tokens which can be found inside an Expression
             //
             entities: {
-                mixinLookup: function () {
+                mixinLookup: function() {
                     return parsers.mixin.call(true, true);
                 },
                 //
@@ -361,36 +387,40 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 //     "milky way" 'he\'s the one!'
                 //
                 quoted: function (forceEscaped) {
-                    var str;
-                    var index = parserInput.i;
-                    var isEscaped = false;
+                    let str;
+                    const index = parserInput.i;
+                    let isEscaped = false;
+
                     parserInput.save();
                     if (parserInput.$char('~')) {
                         isEscaped = true;
-                    }
-                    else if (forceEscaped) {
+                    } else if (forceEscaped) {
                         parserInput.restore();
                         return;
                     }
+
                     str = parserInput.$quoted();
                     if (!str) {
                         parserInput.restore();
                         return;
                     }
                     parserInput.forget();
-                    return new (tree_1.default.Quoted)(str.charAt(0), str.substr(1, str.length - 2), isEscaped, index + currentIndex, fileInfo);
+
+                    return new(tree.Quoted)(str.charAt(0), str.slice(1, -1), isEscaped, index + currentIndex, fileInfo);
                 },
+
                 //
                 // A catch-all word, such as:
                 //
                 //     black border-collapse
                 //
                 keyword: function () {
-                    var k = parserInput.$char('%') || parserInput.$re(/^\[?(?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+\]?/);
+                    const k = parserInput.$char('%') || parserInput.$re(/^\[?(?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+\]?/);
                     if (k) {
-                        return tree_1.default.Color.fromKeyword(k) || new (tree_1.default.Keyword)(k);
+                        return tree.Color.fromKeyword(k) || new(tree.Keyword)(k);
                     }
                 },
+
                 //
                 // A function call
                 //
@@ -399,20 +429,24 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 // The arguments are parsed with the `entities.arguments` parser.
                 //
                 call: function () {
-                    var name;
-                    var args;
-                    var func;
-                    var index = parserInput.i;
+                    let name;
+                    let args;
+                    let func;
+                    const index = parserInput.i;
+
                     // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
                     if (parserInput.peek(/^url\(/i)) {
                         return;
                     }
+
                     parserInput.save();
+
                     name = parserInput.$re(/^([\w-]+|%|~|progid:[\w.]+)\(/);
                     if (!name) {
                         parserInput.forget();
                         return;
                     }
+
                     name = name[1];
                     func = this.customFuncCall(name);
                     if (func) {
@@ -422,40 +456,61 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             return args;
                         }
                     }
+
                     args = this.arguments(args);
+
                     if (!parserInput.$char(')')) {
                         parserInput.restore('Could not parse call arguments or missing \')\'');
                         return;
                     }
+
                     parserInput.forget();
-                    return new (tree_1.default.Call)(name, args, index + currentIndex, fileInfo);
+
+                    return new(tree.Call)(name, args, index + currentIndex, fileInfo);
                 },
+
                 declarationCall: function () {
-                    var validCall;
-                    var args;
-                    var index = parserInput.i;
+                    let validCall;
+                    let args;
+                    const index = parserInput.i;
+
                     parserInput.save();
+
                     validCall = parserInput.$re(/^[\w]+\(/);
                     if (!validCall) {
                         parserInput.forget();
                         return;
                     }
+
                     validCall = validCall.substring(0, validCall.length - 1);
-                    var rule = this.ruleProperty();
-                    var value;
+
+                    // CSS at-rule keywords should never be parsed as declaration calls
+                    if (/^(and|or|not|only|layer)$/i.test(validCall)) {
+                        parserInput.restore();
+                        return;
+                    }
+
+                    let rule = this.ruleProperty();
+                    let value;
+                  
                     if (rule) {
                         value = this.value();
                     }
+                    
                     if (rule && value) {
-                        args = [new (tree_1.default.Declaration)(rule, value, null, null, parserInput.i + currentIndex, fileInfo, true)];
+                        args = [new (tree.Declaration)(rule, value, null, null, parserInput.i + currentIndex, fileInfo, true)];
                     }
+
                     if (!parserInput.$char(')')) {
                         parserInput.restore('Could not parse call arguments or missing \')\'');
                         return;
                     }
+
                     parserInput.forget();
-                    return new (tree_1.default.Call)(validCall, args, index + currentIndex, fileInfo);
+
+                    return new(tree.Call)(validCall, args, index + currentIndex, fileInfo);
                 },
+
                 //
                 // Parsing rules for functions with non-standard args, e.g.:
                 //
@@ -464,74 +519,86 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 //     This is a quick prototype, to be modified/improved when
                 //     more custom-parsed funcs come (e.g. `selector(...)`)
                 //
+
                 customFuncCall: function (name) {
                     /* Ideally the table is to be moved out of here for faster perf.,
                        but it's quite tricky since it relies on all these `parsers`
                        and `expect` available only here */
                     return {
-                        alpha: f(parsers.ieAlpha, true),
+                        alpha:   f(parsers.ieAlpha, true),
                         boolean: f(condition),
-                        'if': f(condition)
+                        'if':    f(condition)
                     }[name.toLowerCase()];
+
                     function f(parse, stop) {
                         return {
-                            parse: parse,
-                            stop: stop // when true - stop after parse() and return its result,
+                            parse, // parsing function
+                            stop   // when true - stop after parse() and return its result,
                             // otherwise continue for plain args
                         };
                     }
+
                     function condition() {
                         return [expect(parsers.condition, 'expected condition')];
                     }
                 },
+
                 arguments: function (prevArgs) {
-                    var argsComma = prevArgs || [];
-                    var argsSemiColon = [];
-                    var isSemiColonSeparated;
-                    var value;
+                    let argsComma = prevArgs || [];
+                    const argsSemiColon = [];
+                    let isSemiColonSeparated;
+                    let value;
+
                     parserInput.save();
+
                     while (true) {
                         if (prevArgs) {
                             prevArgs = false;
-                        }
-                        else {
+                        } else {
                             value = parsers.detachedRuleset() || this.assignment() || parsers.expression();
                             if (!value) {
                                 break;
                             }
+
                             if (value.value && value.value.length == 1) {
                                 value = value.value[0];
                             }
+
                             argsComma.push(value);
                         }
+
                         if (parserInput.$char(',')) {
                             continue;
                         }
+
                         if (parserInput.$char(';') || isSemiColonSeparated) {
                             isSemiColonSeparated = true;
                             value = (argsComma.length < 1) ? argsComma[0]
-                                : new tree_1.default.Value(argsComma);
+                                : new tree.Value(argsComma);
                             argsSemiColon.push(value);
                             argsComma = [];
                         }
                     }
+
                     parserInput.forget();
                     return isSemiColonSeparated ? argsSemiColon : argsComma;
                 },
                 literal: function () {
                     return this.dimension() ||
-                        this.color() ||
-                        this.quoted() ||
-                        this.unicodeDescriptor();
+                           this.color() ||
+                           this.quoted() ||
+                           this.unicodeDescriptor();
                 },
+
                 // Assignments are argument entities for calls.
                 // They are present in ie filter properties as shown below.
                 //
                 //     filter: progid:DXImageTransform.Microsoft.Alpha( *opacity=50* )
                 //
+
                 assignment: function () {
-                    var key;
-                    var value;
+                    let key;
+                    let value;
                     parserInput.save();
                     key = parserInput.$re(/^\w+(?=\s?=)/i);
                     if (!key) {
@@ -545,12 +612,12 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     value = parsers.entity();
                     if (value) {
                         parserInput.forget();
-                        return new (tree_1.default.Assignment)(key, value);
-                    }
-                    else {
+                        return new(tree.Assignment)(key, value);
+                    } else {
                         parserInput.restore();
                     }
                 },
+
                 //
                 // Parse url() tokens
                 //
@@ -559,22 +626,29 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 // to be enclosed within a string, so it can't be parsed as an Expression.
                 //
                 url: function () {
-                    var value;
-                    var index = parserInput.i;
+                    let value;
+                    const index = parserInput.i;
+
                     parserInput.autoCommentAbsorb = false;
+
                     if (!parserInput.$str('url(')) {
                         parserInput.autoCommentAbsorb = true;
                         return;
                     }
+
                     value = this.quoted() || this.variable() || this.property() ||
-                        parserInput.$re(/^(?:(?:\\[()'"])|[^()'"])+/) || '';
+                            parserInput.$re(/^(?:(?:\\[()'"])|[^()'"])+/) || '';
+
                     parserInput.autoCommentAbsorb = true;
+
                     expectChar(')');
-                    return new (tree_1.default.URL)((value.value !== undefined ||
-                        value instanceof tree_1.default.Variable ||
-                        value instanceof tree_1.default.Property) ?
-                        value : new (tree_1.default.Anonymous)(value, index), index + currentIndex, fileInfo);
+
+                    return new(tree.URL)((value.value !== undefined ||
+                        value instanceof tree.Variable ||
+                        value instanceof tree.Property) ?
+                        value : new(tree.Anonymous)(value, index), index + currentIndex, fileInfo);
                 },
+
                 //
                 // A Variable entity, such as `@fink`, in
                 //
@@ -584,31 +658,35 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 // see `parsers.variable`.
                 //
                 variable: function () {
-                    var ch;
-                    var name;
-                    var index = parserInput.i;
+                    let ch;
+                    let name;
+                    const index = parserInput.i;
+
                     parserInput.save();
                     if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^@@?[\w-]+/))) {
                         ch = parserInput.currentChar();
-                        if (ch === '(' || ch === '[' && !parserInput.prevChar().match(/^\s/)) {
+                        if ((ch === '(' && !parserInput.prevChar().match(/^\s/))
+                            || (ch === '[' && !parserInput.prevChar().match(/^\s/))) {
                             // this may be a VariableCall lookup
-                            var result = parsers.variableCall(name);
+                            const result = parsers.variableCall(name);
                             if (result) {
                                 parserInput.forget();
                                 return result;
                             }
                         }
                         parserInput.forget();
-                        return new (tree_1.default.Variable)(name, index + currentIndex, fileInfo);
+                        return new(tree.Variable)(name, index + currentIndex, fileInfo);
                     }
                     parserInput.restore();
                 },
+
                 // A variable entity using the protective {} e.g. @{var}
                 variableCurly: function () {
-                    var curly;
-                    var index = parserInput.i;
+                    let curly;
+                    const index = parserInput.i;
+
                     if (parserInput.currentChar() === '@' && (curly = parserInput.$re(/^@\{([\w-]+)\}/))) {
-                        return new (tree_1.default.Variable)("@".concat(curly[1]), index + currentIndex, fileInfo);
+                        return new(tree.Variable)(`@${curly[1]}`, index + currentIndex, fileInfo);
                     }
                 },
                 //
@@ -617,20 +695,14 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 //     background-color: $color
                 //
                 property: function () {
-                    var name;
-                    var index = parserInput.i;
+                    let name;
+                    const index = parserInput.i;
+
                     if (parserInput.currentChar() === '$' && (name = parserInput.$re(/^\$[\w-]+/))) {
-                        return new (tree_1.default.Property)(name, index + currentIndex, fileInfo);
-                    }
-                },
-                // A property entity useing the protective {} e.g. ${prop}
-                propertyCurly: function () {
-                    var curly;
-                    var index = parserInput.i;
-                    if (parserInput.currentChar() === '$' && (curly = parserInput.$re(/^\$\{([\w-]+)\}/))) {
-                        return new (tree_1.default.Property)("$".concat(curly[1]), index + currentIndex, fileInfo);
+                        return new(tree.Property)(name, index + currentIndex, fileInfo);
                     }
                 },
+
                 //
                 // A Hexadecimal color
                 //
@@ -639,33 +711,36 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 // `rgb` and `hsl` colors are parsed through the `entities.call` parser.
                 //
                 color: function () {
-                    var rgb;
+                    let rgb;
                     parserInput.save();
+
                     if (parserInput.currentChar() === '#' && (rgb = parserInput.$re(/^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})([\w.#[])?/))) {
                         if (!rgb[2]) {
                             parserInput.forget();
-                            return new (tree_1.default.Color)(rgb[1], undefined, rgb[0]);
+                            return new(tree.Color)(rgb[1], undefined, rgb[0]);
                         }
                     }
                     parserInput.restore();
                 },
+
                 colorKeyword: function () {
                     parserInput.save();
-                    var autoCommentAbsorb = parserInput.autoCommentAbsorb;
+                    const autoCommentAbsorb = parserInput.autoCommentAbsorb;
                     parserInput.autoCommentAbsorb = false;
-                    var k = parserInput.$re(/^[_A-Za-z-][_A-Za-z0-9-]+/);
+                    const k = parserInput.$re(/^[_A-Za-z-][_A-Za-z0-9-]+/);
                     parserInput.autoCommentAbsorb = autoCommentAbsorb;
                     if (!k) {
                         parserInput.forget();
                         return;
                     }
                     parserInput.restore();
-                    var color = tree_1.default.Color.fromKeyword(k);
+                    const color = tree.Color.fromKeyword(k);
                     if (color) {
                         parserInput.$str(k);
                         return color;
                     }
                 },
+
                 //
                 // A Dimension, that is, a number and a unit
                 //
@@ -675,57 +750,67 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     if (parserInput.peekNotNumeric()) {
                         return;
                     }
-                    var value = parserInput.$re(/^([+-]?\d*\.?\d+)(%|[a-z_]+)?/i);
+
+                    const value = parserInput.$re(/^([+-]?\d*\.?\d+)(%|[a-z_]+)?/i);
                     if (value) {
-                        return new (tree_1.default.Dimension)(value[1], value[2]);
+                        return new(tree.Dimension)(value[1], value[2]);
                     }
                 },
+
                 //
                 // A unicode descriptor, as is used in unicode-range
                 //
                 // U+0??  or U+00A1-00A9
                 //
                 unicodeDescriptor: function () {
-                    var ud;
+                    let ud;
+
                     ud = parserInput.$re(/^U\+[0-9a-fA-F?]+(-[0-9a-fA-F?]+)?/);
                     if (ud) {
-                        return new (tree_1.default.UnicodeDescriptor)(ud[0]);
+                        return new(tree.UnicodeDescriptor)(ud[0]);
                     }
                 },
+
                 //
                 // JavaScript code to be evaluated
                 //
                 //     `window.location.href`
                 //
                 javascript: function () {
-                    var js;
-                    var index = parserInput.i;
+                    let js;
+                    const index = parserInput.i;
+
                     parserInput.save();
-                    var escape = parserInput.$char('~');
-                    var jsQuote = parserInput.$char('`');
+
+                    const escape = parserInput.$char('~');
+                    const jsQuote = parserInput.$char('`');
+
                     if (!jsQuote) {
                         parserInput.restore();
                         return;
                     }
+
                     js = parserInput.$re(/^[^`]*`/);
                     if (js) {
+                        warn('Inline JavaScript evaluation (backtick expressions) is deprecated and will be removed in Less 5.x. Use Less functions or custom plugins instead.', index, 'DEPRECATED', 'js-eval');
                         parserInput.forget();
-                        return new (tree_1.default.JavaScript)(js.substr(0, js.length - 1), Boolean(escape), index + currentIndex, fileInfo);
+                        return new(tree.JavaScript)(js.slice(0, -1), Boolean(escape), index + currentIndex, fileInfo);
                     }
                     parserInput.restore('invalid javascript definition');
                 }
             },
+
             //
             // The variable part of a variable definition. Used in the `rule` parser
             //
             //     @fink:
             //
             variable: function () {
-                var name;
-                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) {
-                    return name[1];
-                }
+                let name;
+
+                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) { return name[1]; }
             },
+
             //
             // Call a variable value to retrieve a detached ruleset
             // or a value from a detached ruleset's rules.
@@ -735,52 +820,63 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             //     color: @fink[@color];
             //
             variableCall: function (parsedName) {
-                var lookups;
-                var i = parserInput.i;
-                var inValue = !!parsedName;
-                var name = parsedName;
+                let lookups;
+                const i = parserInput.i;
+                const inValue = !!parsedName;
+                let name = parsedName;
+
                 parserInput.save();
+
                 if (name || (parserInput.currentChar() === '@'
                     && (name = parserInput.$re(/^(@[\w-]+)(\(\s*\))?/)))) {
+
                     lookups = this.mixin.ruleLookups();
+
                     if (!lookups && ((inValue && parserInput.$str('()') !== '()') || (name[2] !== '()'))) {
                         parserInput.restore('Missing \'[...]\' lookup in variable call');
                         return;
                     }
+
                     if (!inValue) {
                         name = name[1];
                     }
-                    var call = new tree_1.default.VariableCall(name, i, fileInfo);
+
+                    const call = new tree.VariableCall(name, i, fileInfo);
                     if (!inValue && parsers.end()) {
                         parserInput.forget();
                         return call;
                     }
                     else {
                         parserInput.forget();
-                        return new tree_1.default.NamespaceValue(call, lookups, i, fileInfo);
+                        return new tree.NamespaceValue(call, lookups, i, fileInfo);
                     }
                 }
+
                 parserInput.restore();
             },
+
             //
             // extend syntax - used to extend selectors
             //
-            extend: function (isRule) {
-                var elements;
-                var e;
-                var index = parserInput.i;
-                var option;
-                var extendList;
-                var extend;
+            extend: function(isRule) {
+                let elements;
+                let e;
+                const index = parserInput.i;
+                let option;
+                let extendList;
+                let extend;
+
                 if (!parserInput.$str(isRule ? '&:extend(' : ':extend(')) {
                     return;
                 }
+
                 do {
                     option = null;
                     elements = null;
-                    var first = true;
+                    let first = true;
                     while (!(option = parserInput.$re(/^(!?all)(?=\s*(\)|,))/))) {
                         e = this.element();
+
                         if (!e) {
                             break;
                         }
@@ -789,40 +885,45 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                          * they don't currently parse their contents as selectors.
                          */
                         if (!first && e.combinator.value) {
-                            warn('Targeting complex selectors can have unexpected behavior, and this behavior may change in the future.', index);
+                            warn('Targeting complex selectors can have unexpected behavior, and this behavior may change in the future.', index)
                         }
+
                         first = false;
                         if (elements) {
                             elements.push(e);
-                        }
-                        else {
-                            elements = [e];
+                        } else {
+                            elements = [ e ];
                         }
                     }
+
                     option = option && option[1];
                     if (!elements) {
                         error('Missing target selector for :extend().');
                     }
-                    extend = new (tree_1.default.Extend)(new (tree_1.default.Selector)(elements), option, index + currentIndex, fileInfo);
+                    extend = new(tree.Extend)(new(tree.Selector)(elements), option, index + currentIndex, fileInfo);
                     if (extendList) {
                         extendList.push(extend);
-                    }
-                    else {
-                        extendList = [extend];
+                    } else {
+                        extendList = [ extend ];
                     }
                 } while (parserInput.$char(','));
+
                 expect(/^\)/);
+
                 if (isRule) {
                     expect(/^;/);
                 }
+
                 return extendList;
             },
+
             //
             // extendRule - used in a rule to extend all the parent selectors
             //
-            extendRule: function () {
+            extendRule: function() {
                 return this.extend(true);
             },
+
             //
             // Mixins
             //
@@ -844,31 +945,34 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 // selector for now.
                 //
                 call: function (inValue, getLookup) {
-                    var s = parserInput.currentChar();
-                    var important = false;
-                    var lookups;
-                    var index = parserInput.i;
-                    var elements;
-                    var args;
-                    var hasParens;
-                    var parensIndex;
-                    var parensWS = false;
-                    if (s !== '.' && s !== '#') {
-                        return;
-                    }
+                    const s = parserInput.currentChar();
+                    let important = false;
+                    let lookups;
+                    const index = parserInput.i;
+                    let elements;
+                    let args;
+                    let hasParens;
+                    let parensIndex;
+                    let parensWS = false;
+
+                    if (s !== '.' && s !== '#') { return; }
+
                     parserInput.save(); // stop us absorbing part of an invalid selector
+
                     elements = this.elements();
+
                     if (elements) {
                         parensIndex = parserInput.i;
-                        if (parserInput.$char('(')) {
-                            parensWS = parserInput.isWhitespace(-2);
+                        parensWS = parserInput.isWhitespace(-1);
+                        if (parserInput.$char('(')) { 
                             args = this.args(true).args;
                             expectChar(')');
                             hasParens = true;
                             if (parensWS) {
-                                warn('Whitespace between a mixin name and parentheses for a mixin call is deprecated', parensIndex, 'DEPRECATED');
+                                warn('Whitespace between a mixin name and parentheses for a mixin call is deprecated', parensIndex, 'DEPRECATED', 'mixin-call-whitespace');
                             }
                         }
+
                         if (getLookup !== false) {
                             lookups = this.ruleLookups();
                         }
@@ -876,78 +980,83 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             parserInput.restore();
                             return;
                         }
+
                         if (inValue && !lookups && !hasParens) {
                             // This isn't a valid in-value mixin call
                             parserInput.restore();
                             return;
                         }
+
                         if (!inValue && parsers.important()) {
                             important = true;
                         }
+
                         if (inValue || parsers.end()) {
                             parserInput.forget();
-                            var mixin = new (tree_1.default.mixin.Call)(elements, args, index + currentIndex, fileInfo, !lookups && important);
+                            const mixin = new(tree.mixin.Call)(elements, args, index + currentIndex, fileInfo, !lookups && important);
                             if (lookups) {
-                                return new tree_1.default.NamespaceValue(mixin, lookups);
+                                return new tree.NamespaceValue(mixin, lookups);
                             }
                             else {
                                 if (!hasParens) {
-                                    warn('Calling a mixin without parentheses is deprecated', parensIndex, 'DEPRECATED');
+                                    warn('Calling a mixin without parentheses is deprecated', parensIndex, 'DEPRECATED', 'mixin-call-no-parens');
                                 }
                                 return mixin;
                             }
                         }
                     }
+
                     parserInput.restore();
                 },
                 /**
                  * Matching elements for mixins
                  * (Start with . or # and can have > )
                  */
-                elements: function () {
-                    var elements;
-                    var e;
-                    var c;
-                    var elem;
-                    var elemIndex;
-                    var re = /^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/;
+                elements: function() {
+                    let elements;
+                    let e;
+                    let c;
+                    let elem;
+                    let elemIndex;
+                    const re = /^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/;
                     while (true) {
                         elemIndex = parserInput.i;
                         e = parserInput.$re(re);
+
                         if (!e) {
                             break;
                         }
-                        elem = new (tree_1.default.Element)(c, e, false, elemIndex + currentIndex, fileInfo);
+                        elem = new(tree.Element)(c, e, false, elemIndex + currentIndex, fileInfo);
                         if (elements) {
                             elements.push(elem);
-                        }
-                        else {
-                            elements = [elem];
+                        } else {
+                            elements = [ elem ];
                         }
                         c = parserInput.$char('>');
                     }
                     return elements;
                 },
                 args: function (isCall) {
-                    var entities = parsers.entities;
-                    var returner = { args: null, variadic: false };
-                    var expressions = [];
-                    var argsSemiColon = [];
-                    var argsComma = [];
-                    var isSemiColonSeparated;
-                    var expressionContainsNamed;
-                    var name;
-                    var nameLoop;
-                    var value;
-                    var arg;
-                    var expand;
-                    var hasSep = true;
+                    const entities = parsers.entities;
+                    const returner = { args:null, variadic: false };
+                    let expressions = [];
+                    const argsSemiColon = [];
+                    const argsComma = [];
+                    let isSemiColonSeparated;
+                    let expressionContainsNamed;
+                    let name;
+                    let nameLoop;
+                    let value;
+                    let arg;
+                    let expand;
+                    let hasSep = true;
+
                     parserInput.save();
+
                     while (true) {
                         if (isCall) {
                             arg = parsers.detachedRuleset() || parsers.expression();
-                        }
-                        else {
+                        } else {
                             parserInput.commentStore.length = 0;
                             if (parserInput.$str('...')) {
                                 returner.variadic = true;
@@ -960,25 +1069,28 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             }
                             arg = entities.variable() || entities.property() || entities.literal() || entities.keyword() || this.call(true);
                         }
+
                         if (!arg || !hasSep) {
                             break;
                         }
+
                         nameLoop = null;
                         if (arg.throwAwayComments) {
                             arg.throwAwayComments();
                         }
                         value = arg;
-                        var val = null;
+                        let val = null;
+
                         if (isCall) {
                             // Variable
                             if (arg.value && arg.value.length == 1) {
                                 val = arg.value[0];
                             }
-                        }
-                        else {
+                        } else {
                             val = arg;
                         }
-                        if (val && (val instanceof tree_1.default.Variable || val instanceof tree_1.default.Property)) {
+
+                        if (val && (val instanceof tree.Variable || val instanceof tree.Property)) {
                             if (parserInput.$char(':')) {
                                 if (expressions.length > 0) {
                                     if (isSemiColonSeparated) {
@@ -986,20 +1098,20 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                                     }
                                     expressionContainsNamed = true;
                                 }
+
                                 value = parsers.detachedRuleset() || parsers.expression();
+
                                 if (!value) {
                                     if (isCall) {
                                         error('could not understand value for named argument');
-                                    }
-                                    else {
+                                    } else {
                                         parserInput.restore();
                                         returner.args = [];
                                         return returner;
                                     }
                                 }
                                 nameLoop = (name = val.name);
-                            }
-                            else if (parserInput.$str('...')) {
+                            } else if (parserInput.$str('...')) {
                                 if (!isCall) {
                                     returner.variadic = true;
                                     if (parserInput.$char(';') && !isSemiColonSeparated) {
@@ -1008,39 +1120,46 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                                     (isSemiColonSeparated ? argsSemiColon : argsComma)
                                         .push({ name: arg.name, variadic: true });
                                     break;
-                                }
-                                else {
+                                } else {
                                     expand = true;
                                 }
-                            }
-                            else if (!isCall) {
+                            } else if (!isCall) {
                                 name = nameLoop = val.name;
                                 value = null;
                             }
                         }
+
                         if (value) {
                             expressions.push(value);
                         }
-                        argsComma.push({ name: nameLoop, value: value, expand: expand });
+
+                        argsComma.push({ name:nameLoop, value, expand });
+
                         if (parserInput.$char(',')) {
                             hasSep = true;
                             continue;
                         }
                         hasSep = parserInput.$char(';') === ';';
+
                         if (hasSep || isSemiColonSeparated) {
+
                             if (expressionContainsNamed) {
                                 error('Cannot mix ; and , as delimiter types');
                             }
+
                             isSemiColonSeparated = true;
+
                             if (expressions.length > 1) {
-                                value = new (tree_1.default.Value)(expressions);
+                                value = new(tree.Value)(expressions);
                             }
-                            argsSemiColon.push({ name: name, value: value, expand: expand });
+                            argsSemiColon.push({ name, value, expand });
+
                             name = null;
                             expressions = [];
                             expressionContainsNamed = false;
                         }
                     }
+
                     parserInput.forget();
                     returner.args = isSemiColonSeparated ? argsSemiColon : argsComma;
                     return returner;
@@ -1065,23 +1184,27 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 // the `{...}` block.
                 //
                 definition: function () {
-                    var name;
-                    var params = [];
-                    var match;
-                    var ruleset;
-                    var cond;
-                    var variadic = false;
+                    let name;
+                    let params = [];
+                    let match;
+                    let ruleset;
+                    let cond;
+                    let variadic = false;
                     if ((parserInput.currentChar() !== '.' && parserInput.currentChar() !== '#') ||
                         parserInput.peek(/^[^{]*\}/)) {
                         return;
                     }
+
                     parserInput.save();
+
                     match = parserInput.$re(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/);
                     if (match) {
                         name = match[1];
-                        var argInfo = this.args(false);
+
+                        const argInfo = this.args(false);
                         params = argInfo.args;
                         variadic = argInfo.variadic;
+
                         // .mixincall("@{a}");
                         // looks a bit like a mixin definition..
                         // also
@@ -1091,29 +1214,34 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             parserInput.restore('Missing closing \')\'');
                             return;
                         }
+
                         parserInput.commentStore.length = 0;
+
                         if (parserInput.$str('when')) { // Guard
                             cond = expect(parsers.conditions, 'expected condition');
                         }
+
                         ruleset = parsers.block();
+
                         if (ruleset) {
                             parserInput.forget();
-                            return new (tree_1.default.mixin.Definition)(name, params, ruleset, cond, variadic);
-                        }
-                        else {
+                            return new(tree.mixin.Definition)(name, params, ruleset, cond, variadic);
+                        } else {
                             parserInput.restore();
                         }
-                    }
-                    else {
+                    } else {
                         parserInput.restore();
                     }
                 },
-                ruleLookups: function () {
-                    var rule;
-                    var lookups = [];
+
+                ruleLookups: function() {
+                    let rule;
+                    const lookups = [];
+
                     if (parserInput.currentChar() !== '[') {
                         return;
                     }
+
                     while (true) {
                         parserInput.save();
                         rule = this.lookupValue();
@@ -1128,21 +1256,27 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         return lookups;
                     }
                 },
-                lookupValue: function () {
+
+                lookupValue: function() {
                     parserInput.save();
+
                     if (!parserInput.$char('[')) {
                         parserInput.restore();
                         return;
                     }
-                    var name = parserInput.$re(/^(?:[@$]{0,2})[_a-zA-Z0-9-]*/);
+
+                    const name = parserInput.$re(/^(?:[@$]{0,2})[_a-zA-Z0-9-]*/);
+
                     if (!parserInput.$char(']')) {
                         parserInput.restore();
                         return;
                     }
+
                     if (name || name === '') {
                         parserInput.forget();
                         return name;
                     }
+
                     parserInput.restore();
                 }
             },
@@ -1151,11 +1285,13 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // and can be found inside a rule's value.
             //
             entity: function () {
-                var entities = this.entities;
+                const entities = this.entities;
+
                 return this.comment() || entities.literal() || entities.variable() || entities.url() ||
                     entities.property() || entities.call() || entities.keyword() || this.mixin.call(true) ||
                     entities.javascript();
             },
+
             //
             // A Declaration terminator. Note that we use `peek()` to check for '}',
             // because the `block` rule will be expecting it, but we still need to make sure
@@ -1164,26 +1300,27 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             end: function () {
                 return parserInput.$char(';') || parserInput.peek('}');
             },
+
             //
             // IE's alpha function
             //
             //     alpha(opacity=88)
             //
             ieAlpha: function () {
-                var value;
+                let value;
+
                 // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
-                if (!parserInput.$re(/^opacity=/i)) {
-                    return;
-                }
+                if (!parserInput.$re(/^opacity=/i)) { return; }
                 value = parserInput.$re(/^\d+/);
                 if (!value) {
                     value = expect(parsers.entities.variable, 'Could not parse alpha');
-                    value = "@{".concat(value.name.slice(1), "}");
+                    value = `@{${value.name.slice(1)}}`;
                 }
                 expectChar(')');
-                return new tree_1.default.Quoted('', "alpha(opacity=".concat(value, ")"));
+                return new tree.Quoted('', `alpha(opacity=${value})`);
             },
-            /**
+
+            /** 
              * A Selector Element
              *
              *   div
@@ -1196,54 +1333,54 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
              * and an element name, such as a tag a class, or `*`.
              */
             element: function () {
-                var e;
-                var c;
-                var v;
-                var index = parserInput.i;
+                let e;
+                let c;
+                let v;
+                const index = parserInput.i;
+
                 c = this.combinator();
+
                 /** This selector parser is quite simplistic and will pass a number of invalid selectors. */
                 e = parserInput.$re(/^(?:\d+\.\d+|\d+)%/) ||
                     // eslint-disable-next-line no-control-regex
                     parserInput.$re(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) ||
                     parserInput.$char('*') || parserInput.$char('&') || this.attribute() ||
-                    parserInput.$re(/^\([^&()@]+\)/) || parserInput.$re(/^[.#:](?=@)/) ||
+                    parserInput.$re(/^\([^&()@]+\)/) ||  parserInput.$re(/^[.#:](?=@)/) ||
                     this.entities.variableCurly();
+
                 if (!e) {
                     parserInput.save();
                     if (parserInput.$char('(')) {
                         if ((v = this.selector(false))) {
-                            var selectors = [];
+                            let selectors = [];
                             while (parserInput.$char(',')) {
                                 selectors.push(v);
-                                selectors.push(new anonymous_1.default(','));
+                                selectors.push(new Anonymous(','));
                                 v = this.selector(false);
                             }
                             selectors.push(v);
+                                                        
                             if (parserInput.$char(')')) {
                                 if (selectors.length > 1) {
-                                    e = new (tree_1.default.Paren)(new selector_1.default(selectors));
-                                }
-                                else {
-                                    e = new (tree_1.default.Paren)(v);
+                                    e = new (tree.Paren)(new Selector(selectors));
+                                } else {
+                                    e = new(tree.Paren)(v);
                                 }
                                 parserInput.forget();
-                            }
-                            else {
+                            } else {
                                 parserInput.restore('Missing closing \')\'');
                             }
-                        }
-                        else {
+                        } else {
                             parserInput.restore('Missing closing \')\'');
                         }
-                    }
-                    else {
+                    } else {
                         parserInput.forget();
                     }
                 }
-                if (e) {
-                    return new (tree_1.default.Element)(c, e, e instanceof tree_1.default.Variable, index + currentIndex, fileInfo);
-                }
+
+                if (e) { return new(tree.Element)(c, e, e instanceof tree.Variable, index + currentIndex, fileInfo); }
             },
+
             //
             // Combinators combine elements together, in a Selector.
             //
@@ -1254,32 +1391,30 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // we deal with this in *combinator.js*.
             //
             combinator: function () {
-                var c = parserInput.currentChar();
+                let c = parserInput.currentChar();
+
                 if (c === '/') {
                     parserInput.save();
-                    var slashedCombinator = parserInput.$re(/^\/[a-z]+\//i);
+                    const slashedCombinator = parserInput.$re(/^\/[a-z]+\//i);
                     if (slashedCombinator) {
                         parserInput.forget();
-                        return new (tree_1.default.Combinator)(slashedCombinator);
+                        return new(tree.Combinator)(slashedCombinator);
                     }
                     parserInput.restore();
                 }
+
                 if (c === '>' || c === '+' || c === '~' || c === '|' || c === '^') {
                     parserInput.i++;
                     if (c === '^' && parserInput.currentChar() === '^') {
                         c = '^^';
                         parserInput.i++;
                     }
-                    while (parserInput.isWhitespace()) {
-                        parserInput.i++;
-                    }
-                    return new (tree_1.default.Combinator)(c);
-                }
-                else if (parserInput.isWhitespace(-1)) {
-                    return new (tree_1.default.Combinator)(' ');
-                }
-                else {
-                    return new (tree_1.default.Combinator)(null);
+                    while (parserInput.isWhitespace()) { parserInput.i++; }
+                    return new(tree.Combinator)(c);
+                } else if (parserInput.isWhitespace(-1)) {
+                    return new(tree.Combinator)(' ');
+                } else {
+                    return new(tree.Combinator)(null);
                 }
             },
             //
@@ -1292,43 +1427,35 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // Selectors are made out of one or more Elements, see above.
             //
             selector: function (isLess) {
-                var index = parserInput.i;
-                var elements;
-                var extendList;
-                var c;
-                var e;
-                var allExtends;
-                var when;
-                var condition;
+                const index = parserInput.i;
+                let elements;
+                let extendList;
+                let c;
+                let e;
+                let allExtends;
+                let when;
+                let condition;
                 isLess = isLess !== false;
                 while ((isLess && (extendList = this.extend())) || (isLess && (when = parserInput.$str('when'))) || (e = this.element())) {
                     if (when) {
                         condition = expect(this.conditions, 'expected condition');
-                    }
-                    else if (condition) {
+                    } else if (condition) {
                         error('CSS guard can only be used at the end of selector');
-                    }
-                    else if (extendList) {
+                    } else if (extendList) {
                         if (allExtends) {
                             allExtends = allExtends.concat(extendList);
-                        }
-                        else {
+                        } else {
                             allExtends = extendList;
                         }
-                    }
-                    else {
-                        if (allExtends) {
-                            error('Extend can only be used at the end of selector');
-                        }
+                    } else {
+                        if (allExtends) { error('Extend can only be used at the end of selector'); }
                         c = parserInput.currentChar();
-                        if (Array.isArray(e)) {
-                            e.forEach(function (ele) { return elements.push(ele); });
-                        }
-                        if (elements) {
+                        if (Array.isArray(e)){
+                            e.forEach(ele => elements.push(ele));
+                        } if (elements) {
                             elements.push(e);
-                        }
-                        else {
-                            elements = [e];
+                        } else {
+                            elements = [ e ];
                         }
                         e = null;
                     }
@@ -1336,16 +1463,13 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         break;
                     }
                 }
-                if (elements) {
-                    return new (tree_1.default.Selector)(elements, allExtends, condition, index + currentIndex, fileInfo);
-                }
-                if (allExtends) {
-                    error('Extend must be used to extend a selector, it cannot be used on its own');
-                }
+
+                if (elements) { return new(tree.Selector)(elements, allExtends, condition, index + currentIndex, fileInfo); }
+                if (allExtends) { error('Extend must be used to extend a selector, it cannot be used on its own'); }
             },
             selectors: function () {
-                var s;
-                var selectors;
+                let s;
+                let selectors;
                 while (true) {
                     s = this.selector();
                     if (!s) {
@@ -1353,17 +1477,14 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                     if (selectors) {
                         selectors.push(s);
-                    }
-                    else {
-                        selectors = [s];
+                    } else {
+                        selectors = [ s ];
                     }
                     parserInput.commentStore.length = 0;
                     if (s.condition && selectors.length > 1) {
                         error('Guards are only currently allowed on a single selector.');
                     }
-                    if (!parserInput.$char(',')) {
-                        break;
-                    }
+                    if (!parserInput.$char(',')) { break; }
                     if (s.condition) {
                         error('Guards are only currently allowed on a single selector.');
                     }
@@ -1372,21 +1493,22 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 return selectors;
             },
             attribute: function () {
-                if (!parserInput.$char('[')) {
-                    return;
-                }
-                var entities = this.entities;
-                var key;
-                var val;
-                var op;
+                if (!parserInput.$char('[')) { return; }
+
+                const entities = this.entities;
+                let key;
+                let val;
+                let op;
                 //
                 // case-insensitive flag
                 // e.g. [attr operator value i]
                 //
-                var cif;
+                let cif;
+
                 if (!(key = entities.variableCurly())) {
                     key = expect(/^(?:[_A-Za-z0-9-*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/);
                 }
+
                 op = parserInput.$re(/^[|~*$^]?=/);
                 if (op) {
                     val = entities.quoted() || parserInput.$re(/^[0-9]+%/) || parserInput.$re(/^[\w-]+/) || entities.variableCurly();
@@ -1394,30 +1516,35 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         cif = parserInput.$re(/^[iIsS]/);
                     }
                 }
+
                 expectChar(']');
-                return new (tree_1.default.Attribute)(key, op, val, cif);
+
+                return new(tree.Attribute)(key, op, val, cif);
             },
+
             //
             // The `block` rule is used by `ruleset` and `mixin.definition`.
             // It's a wrapper around the `primary` rule, with added `{}`.
             //
             block: function () {
-                var content;
+                let content;
                 if (parserInput.$char('{') && (content = this.primary()) && parserInput.$char('}')) {
                     return content;
                 }
             },
-            blockRuleset: function () {
-                var block = this.block();
+
+            blockRuleset: function() {
+                let block = this.block();
                 if (block) {
-                    block = new tree_1.default.Ruleset(null, block);
+                    return new tree.Ruleset(null, block);
                 }
-                return block;
             },
-            detachedRuleset: function () {
-                var argInfo;
-                var params;
-                var variadic;
+
+            detachedRuleset: function() {
+                let argInfo;
+                let params;
+                let variadic;
+
                 parserInput.save();
                 if (parserInput.$re(/^[.#]\(/)) {
                     /**
@@ -1434,74 +1561,81 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         return;
                     }
                 }
-                var blockRuleset = this.blockRuleset();
+                const blockRuleset = this.blockRuleset();
                 if (blockRuleset) {
                     parserInput.forget();
                     if (params) {
-                        return new tree_1.default.mixin.Definition(null, params, blockRuleset, null, variadic);
+                        return new tree.mixin.Definition(null, params, blockRuleset, null, variadic);
                     }
-                    return new tree_1.default.DetachedRuleset(blockRuleset);
+                    return new tree.DetachedRuleset(blockRuleset);
                 }
                 parserInput.restore();
             },
+
             //
             // div, .class, body > p {...}
             //
             ruleset: function () {
-                var selectors;
-                var rules;
-                var debugInfo;
+                let selectors;
+                let rules;
+                let debugInfo;
+
                 parserInput.save();
+
                 if (context.dumpLineNumbers) {
                     debugInfo = getDebugInfo(parserInput.i);
                 }
+
                 selectors = this.selectors();
+
                 if (selectors && (rules = this.block())) {
                     parserInput.forget();
-                    var ruleset = new (tree_1.default.Ruleset)(selectors, rules, context.strictImports);
+                    const ruleset = new(tree.Ruleset)(selectors, rules, context.strictImports);
                     if (context.dumpLineNumbers) {
                         ruleset.debugInfo = debugInfo;
                     }
                     return ruleset;
-                }
-                else {
+                } else {
                     parserInput.restore();
                 }
             },
             declaration: function () {
-                var name;
-                var value;
-                var index = parserInput.i;
-                var hasDR;
-                var c = parserInput.currentChar();
-                var important;
-                var merge;
-                var isVariable;
-                if (c === '.' || c === '#' || c === '&' || c === ':') {
-                    return;
-                }
+                let name;
+                let value;
+                const index = parserInput.i;
+                let hasDR;
+                const c = parserInput.currentChar();
+                let important;
+                let merge;
+                let isVariable;
+
+                if (c === '.' || c === '#' || c === '&' || c === ':') { return; }
+
                 parserInput.save();
+
                 name = this.variable() || this.ruleProperty();
                 if (name) {
                     isVariable = typeof name === 'string';
+
                     if (isVariable) {
                         value = this.detachedRuleset();
                         if (value) {
                             hasDR = true;
                         }
                     }
+
                     parserInput.commentStore.length = 0;
                     if (!value) {
                         // a name returned by this.ruleProperty() is always an array of the form:
                         // [string-1, ..., string-n, ""] or [string-1, ..., string-n, "+"]
                         // where each item is a tree.Keyword or tree.Variable
                         merge = !isVariable && name.length > 1 && name.pop().value;
+
                         // Custom property values get permissive parsing
                         if (name[0].value && name[0].value.slice(0, 2) === '--') {
                             if (parserInput.$char(';')) {
-                                value = new anonymous_1.default('');
-                            }
-                            else {
+                                value = new Anonymous('');
+                            } else {
                                 value = this.permissiveValue(/[;}]/, true);
                             }
                         }
@@ -1513,15 +1647,16 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         if (value) {
                             parserInput.forget();
                             // anonymous values absorb the end ';' which is required for them to work
-                            return new (tree_1.default.Declaration)(name, value, false, merge, index + currentIndex, fileInfo);
+                            return new(tree.Declaration)(name, value, false, merge, index + currentIndex, fileInfo);
                         }
+
                         if (!value) {
                             value = this.value();
                         }
+
                         if (value) {
                             important = this.important();
-                        }
-                        else if (isVariable) {
+                        } else if (isVariable) {
                             /**
                              * As a last resort, try permissiveValue
                              *
@@ -1531,23 +1666,23 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             value = this.permissiveValue();
                         }
                     }
+
                     if (value && (this.end() || hasDR)) {
                         parserInput.forget();
-                        return new (tree_1.default.Declaration)(name, value, important, merge, index + currentIndex, fileInfo);
+                        return new(tree.Declaration)(name, value, important, merge, index + currentIndex, fileInfo);
                     }
                     else {
                         parserInput.restore();
                     }
-                }
-                else {
+                } else {
                     parserInput.restore();
                 }
             },
             anonymousValue: function () {
-                var index = parserInput.i;
-                var match = parserInput.$re(/^([^.#@$+/'"*`(;{}-]*);/);
+                const index = parserInput.i;
+                const match = parserInput.$re(/^([^.#@$+/'"*`(;{}-]*);/);
                 if (match) {
-                    return new (tree_1.default.Anonymous)(match[1], index + currentIndex);
+                    return new(tree.Anonymous)(match[1], index + currentIndex);
                 }
             },
             /**
@@ -1558,23 +1693,23 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
              * First, it will try to parse comments and entities to reach
              * the end. This is mostly like the Expression parser except no
              * math is allowed.
-             *
+             * 
              * @param {RexExp} untilTokens - Characters to stop parsing at
              */
             permissiveValue: function (untilTokens) {
-                var i;
-                var e;
-                var done;
-                var value;
-                var tok = untilTokens || ';';
-                var index = parserInput.i;
-                var result = [];
+                let i;
+                let e;
+                let done;
+                let value;
+                const tok = untilTokens || ';';
+                const index = parserInput.i;
+                const result = [];
+
                 function testCurrentChar() {
-                    var char = parserInput.currentChar();
+                    const char = parserInput.currentChar();
                     if (typeof tok === 'string') {
                         return char === tok;
-                    }
-                    else {
+                    } else {
                         return tok.test(char);
                     }
                 }
@@ -1593,13 +1728,15 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         value.push(e);
                     }
                     if (parserInput.peek(',')) {
-                        value.push(new (tree_1.default.Anonymous)(',', parserInput.i));
+                        value.push(new (tree.Anonymous)(',', parserInput.i));
                         parserInput.$char(',');
                     }
                 } while (e);
+
                 done = testCurrentChar();
+
                 if (value.length > 0) {
-                    value = new (tree_1.default.Expression)(value);
+                    value = new(tree.Expression)(value);
                     if (done) {
                         return value;
                     }
@@ -1608,40 +1745,42 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                     // Preserve space before $parseUntil as it will not
                     if (parserInput.prevChar() === ' ') {
-                        result.push(new tree_1.default.Anonymous(' ', index));
+                        result.push(new tree.Anonymous(' ', index));
                     }
                 }
                 parserInput.save();
+
                 value = parserInput.$parseUntil(tok);
+
                 if (value) {
                     if (typeof value === 'string') {
-                        error("Expected '".concat(value, "'"), 'Parse');
+                        error(`Expected '${value}'`, 'Parse');
                     }
                     if (value.length === 1 && value[0] === ' ') {
                         parserInput.forget();
-                        return new tree_1.default.Anonymous('', index);
+                        return new tree.Anonymous('', index);
                     }
                     /** @type {string} */
-                    var item = void 0;
+                    let item;
                     for (i = 0; i < value.length; i++) {
                         item = value[i];
                         if (Array.isArray(item)) {
                             // Treat actual quotes as normal quoted values
-                            result.push(new tree_1.default.Quoted(item[0], item[1], true, index, fileInfo));
+                            result.push(new tree.Quoted(item[0], item[1], true, index, fileInfo));
                         }
                         else {
                             if (i === value.length - 1) {
                                 item = item.trim();
                             }
                             // Treat like quoted values, but replace vars like unquoted expressions
-                            var quote = new tree_1.default.Quoted('\'', item, true, index, fileInfo);
-                            var variableRegex = /@([\w-]+)/g;
-                            var propRegex = /\$([\w-]+)/g;
+                            const quote = new tree.Quoted('\'', item, true, index, fileInfo);
+                            const variableRegex = /@([\w-]+)/g;
+                            const propRegex = /\$([\w-]+)/g;
                             if (variableRegex.test(item)) {
-                                warn('@[ident] in unknown values will not be evaluated as variables in the future. Use @{[ident]}', index, 'DEPRECATED');
+                                warn('@[ident] in unknown values will not be evaluated as variables in the future. Use @{[ident]}', index, 'DEPRECATED', 'variable-in-unknown-value');
                             }
                             if (propRegex.test(item)) {
-                                warn('$[ident] in unknown values will not be evaluated as property references in the future. Use ${[ident]}', index, 'DEPRECATED');
+                                warn('$[ident] in unknown values will not be evaluated as property references in the future. Use ${[ident]}', index, 'DEPRECATED', 'property-in-unknown-value');
                             }
                             quote.variableRegex = /@([\w-]+)|@{([\w-]+)}/g;
                             quote.propRegex = /\$([\w-]+)|\${([\w-]+)}/g;
@@ -1649,10 +1788,11 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         }
                     }
                     parserInput.forget();
-                    return new tree_1.default.Expression(result, true);
+                    return new tree.Expression(result, true);
                 }
                 parserInput.restore();
             },
+
             //
             // An @import atrule
             //
@@ -1664,20 +1804,24 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // stored in `import`, which we pass to the Import constructor.
             //
             'import': function () {
-                var path;
-                var features;
-                var index = parserInput.i;
-                var dir = parserInput.$re(/^@import\s+/);
+                let path;
+                let features;
+                const index = parserInput.i;
+
+                const dir = parserInput.$re(/^@import\s+/);
+
                 if (dir) {
-                    var options = (dir ? this.importOptions() : null) || {};
+                    const options = (dir ? this.importOptions() : null) || {};
+
                     if ((path = this.entities.quoted() || this.entities.url())) {
                         features = this.mediaFeatures({});
+
                         if (!parserInput.$char(';')) {
                             parserInput.i = index;
                             error('missing semi-colon or unrecognised media features on import');
                         }
-                        features = features && new (tree_1.default.Value)(features);
-                        return new (tree_1.default.Import)(path, features, options, index + currentIndex, fileInfo);
+                        features = features && new(tree.Value)(features);
+                        return new(tree.Import)(path, features, options, index + currentIndex, fileInfo);
                     }
                     else {
                         parserInput.i = index;
@@ -1685,15 +1829,15 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                 }
             },
-            importOptions: function () {
-                var o;
-                var options = {};
-                var optionName;
-                var value;
+
+            importOptions: function() {
+                let o;
+                const options = {};
+                let optionName;
+                let value;
+
                 // list of options, surrounded by parens
-                if (!parserInput.$char('(')) {
-                    return null;
-                }
+                if (!parserInput.$char('(')) { return null; }
                 do {
                     o = this.importOption();
                     if (o) {
@@ -1710,27 +1854,27 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                                 break;
                         }
                         options[optionName] = value;
-                        if (!parserInput.$char(',')) {
-                            break;
-                        }
+                        if (!parserInput.$char(',')) { break; }
                     }
                 } while (o);
                 expectChar(')');
                 return options;
             },
-            importOption: function () {
-                var opt = parserInput.$re(/^(less|css|multiple|once|inline|reference|optional)/);
+
+            importOption: function() {
+                const opt = parserInput.$re(/^(less|css|multiple|once|inline|reference|optional)/);
                 if (opt) {
                     return opt[1];
                 }
             },
+
             mediaFeature: function (syntaxOptions) {
-                var entities = this.entities;
-                var nodes = [];
-                var e;
-                var p;
-                var rangeP;
-                var spacing = false;
+                const entities = this.entities;
+                const nodes = [];
+                let e;
+                let p;
+                let rangeP;
+                let spacing = false;
                 parserInput.save();
                 do {
                     parserInput.save();
@@ -1738,129 +1882,143 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         spacing = true;
                     }
                     parserInput.restore();
-                    e = entities.declarationCall.bind(this)() || entities.keyword() || entities.variable() || entities.mixinLookup();
+
+                    e = entities.declarationCall.bind(this)() || entities.keyword() || entities.variable() || entities.mixinLookup()
                     if (e) {
                         nodes.push(e);
-                    }
-                    else if (parserInput.$char('(')) {
+                        if (e.type === 'Variable' ||
+                            (e.type === 'Keyword' && /^(and|or|not|only)$/i.test(e.value))) {
+                            spacing = true;
+                        }
+                    } else if (parserInput.$char('(')) {
                         p = this.property();
                         parserInput.save();
                         if (!p && syntaxOptions.queryInParens && parserInput.$re(/^[0-9a-z-]*\s*([<>]=|<=|>=|[<>]|=)/)) {
                             parserInput.restore();
                             p = this.condition();
+
                             parserInput.save();
                             rangeP = this.atomicCondition(null, p.rvalue);
                             if (!rangeP) {
                                 parserInput.restore();
                             }
-                        }
-                        else {
+                        } else {
                             parserInput.restore();
                             e = this.value();
                         }
                         if (parserInput.$char(')')) {
                             if (p && !e) {
-                                nodes.push(new (tree_1.default.Paren)(new (tree_1.default.QueryInParens)(p.op, p.lvalue, p.rvalue, rangeP ? rangeP.op : null, rangeP ? rangeP.rvalue : null, p._index)));
+                                nodes.push(new (tree.Paren)(new (tree.QueryInParens)(p.op, p.lvalue, p.rvalue, rangeP ? rangeP.op : null, rangeP ? rangeP.rvalue : null, p._index)));
                                 e = p;
-                            }
-                            else if (p && e) {
-                                nodes.push(new (tree_1.default.Paren)(new (tree_1.default.Declaration)(p, e, null, null, parserInput.i + currentIndex, fileInfo, true)));
+                            } else if (p && e) {
+                                nodes.push(new (tree.Paren)(new (tree.Declaration)(p, e, null, null, parserInput.i + currentIndex, fileInfo, true)));
                                 if (!spacing) {
                                     nodes[nodes.length - 1].noSpacing = true;
                                 }
                                 spacing = false;
-                            }
-                            else if (e) {
-                                nodes.push(new (tree_1.default.Paren)(e));
+                            } else if (e) {
+                                nodes.push(new(tree.Paren)(e));
                                 spacing = false;
-                            }
-                            else {
+                            } else {
                                 error('badly formed media feature definition');
                             }
-                        }
-                        else {
+                        } else {
                             error('Missing closing \')\'', 'Parse');
                         }
                     }
                 } while (e);
+
                 parserInput.forget();
                 if (nodes.length > 0) {
-                    return new (tree_1.default.Expression)(nodes);
+                    return new(tree.Expression)(nodes);
                 }
             },
+
             mediaFeatures: function (syntaxOptions) {
-                var entities = this.entities;
-                var features = [];
-                var e;
+                const entities = this.entities;
+                const features = [];
+                let e;
                 do {
                     e = this.mediaFeature(syntaxOptions);
                     if (e) {
                         features.push(e);
-                        if (!parserInput.$char(',')) {
-                            break;
-                        }
+                        if (!parserInput.$char(',')) { break; }
                         else if (!features[features.length - 1].noSpacing) {
                             features[features.length - 1].noSpacing = false;
                         }
-                    }
-                    else {
+                    } else {
                         e = entities.variable() || entities.mixinLookup();
                         if (e) {
                             features.push(e);
-                            if (!parserInput.$char(',')) {
-                                break;
-                            }
+                            if (!parserInput.$char(',')) { break; }
                             else if (!features[features.length - 1].noSpacing) {
                                 features[features.length - 1].noSpacing = false;
                             }
                         }
                     }
                 } while (e);
+
                 return features.length > 0 ? features : null;
             },
+
             prepareAndGetNestableAtRule: function (treeType, index, debugInfo, syntaxOptions) {
-                var features = this.mediaFeatures(syntaxOptions);
-                var rules = this.block();
+                const features = this.mediaFeatures(syntaxOptions);
+
+                const rules = this.block();
+
                 if (!rules) {
                     error('media definitions require block statements after any features');
                 }
+
                 parserInput.forget();
-                var atRule = new (treeType)(rules, features, index + currentIndex, fileInfo);
+
+                const atRule = new (treeType)(rules, features, index + currentIndex, fileInfo);
                 if (context.dumpLineNumbers) {
                     atRule.debugInfo = debugInfo;
                 }
+
                 return atRule;
             },
+
             nestableAtRule: function () {
-                var debugInfo;
-                var index = parserInput.i;
+                let debugInfo;
+                const index = parserInput.i;
+
                 if (context.dumpLineNumbers) {
                     debugInfo = getDebugInfo(index);
                 }
                 parserInput.save();
+
                 if (parserInput.$peekChar('@')) {
                     if (parserInput.$str('@media')) {
-                        return this.prepareAndGetNestableAtRule(tree_1.default.Media, index, debugInfo, atrule_syntax_1.MediaSyntaxOptions);
+                        return this.prepareAndGetNestableAtRule(tree.Media, index, debugInfo, MediaSyntaxOptions);
                     }
+
                     if (parserInput.$str('@container')) {
-                        return this.prepareAndGetNestableAtRule(tree_1.default.Container, index, debugInfo, atrule_syntax_1.ContainerSyntaxOptions);
+                        return this.prepareAndGetNestableAtRule(tree.Container, index, debugInfo, ContainerSyntaxOptions);
                     }
                 }
+
                 parserInput.restore();
             },
+
             //
+
             // A @plugin directive, used to import plugins dynamically.
             //
             //     @plugin (args) "lib";
             //
             plugin: function () {
-                var path;
-                var args;
-                var options;
-                var index = parserInput.i;
-                var dir = parserInput.$re(/^@plugin\s+/);
+                let path;
+                let args;
+                let options;
+                const index = parserInput.i;
+                const dir   = parserInput.$re(/^@plugin\s+/);
+
                 if (dir) {
+                    warn('The @plugin directive is deprecated and will be replaced in Less 5.x. Use --plugin CLI option or the programmatic plugin API instead.', index, 'DEPRECATED', 'at-plugin');
                     args = this.pluginArgs();
+
                     if (args) {
                         options = {
                             pluginArgs: args,
@@ -1870,12 +2028,14 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     else {
                         options = { isPlugin: true };
                     }
+
                     if ((path = this.entities.quoted() || this.entities.url())) {
+
                         if (!parserInput.$char(';')) {
                             parserInput.i = index;
                             error('missing semi-colon on @plugin');
                         }
-                        return new (tree_1.default.Import)(path, null, options, index + currentIndex, fileInfo);
+                        return new(tree.Import)(path, null, options, index + currentIndex, fileInfo);
                     }
                     else {
                         parserInput.i = index;
@@ -1883,14 +2043,15 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                 }
             },
-            pluginArgs: function () {
+
+            pluginArgs: function() {
                 // list of options, surrounded by parens
                 parserInput.save();
                 if (!parserInput.$char('(')) {
                     parserInput.restore();
                     return null;
                 }
-                var args = parserInput.$re(/^\s*([^);]+)\)\s*/);
+                const args = parserInput.$re(/^\s*([^);]+)\)\s*/);
                 if (args[1]) {
                     parserInput.forget();
                     return args[1].trim();
@@ -1940,6 +2101,7 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 else {
                     parserInput.forget();
                 }
+                    
                 return [rules, value, isKeywordList];
             },
             //
@@ -1948,33 +2110,36 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             //     @charset "utf-8";
             //
             atrule: function () {
-                var index = parserInput.i;
-                var name;
-                var value;
-                var rules;
-                var nonVendorSpecificName;
-                var hasIdentifier;
-                var hasExpression;
-                var hasUnknown;
-                var hasBlock = true;
-                var isRooted = true;
-                var isKeywordList = false;
-                if (parserInput.currentChar() !== '@') {
-                    return;
-                }
+                const index = parserInput.i;
+                let name;
+                let value;
+                let rules;
+                let nonVendorSpecificName;
+                let hasIdentifier;
+                let hasExpression;
+                let hasUnknown;
+                let hasBlock = true;
+                let isRooted = true;
+                let isKeywordList = false;
+
+                if (parserInput.currentChar() !== '@') { return; }
+
                 value = this['import']() || this.plugin() || this.nestableAtRule();
                 if (value) {
                     return value;
                 }
+
                 parserInput.save();
+
                 name = parserInput.$re(/^@[a-z-]+/);
-                if (!name) {
-                    return;
-                }
+
+                if (!name) { return; }
+
                 nonVendorSpecificName = name;
                 if (name.charAt(1) == '-' && name.indexOf('-', 2) > 0) {
-                    nonVendorSpecificName = "@".concat(name.slice(name.indexOf('-', 2) + 1));
+                    nonVendorSpecificName = `@${name.slice(name.indexOf('-', 2) + 1)}`;
                 }
+
                 switch (nonVendorSpecificName) {
                     case '@charset':
                         hasIdentifier = true;
@@ -2003,33 +2168,35 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         hasUnknown = true;
                         break;
                 }
+
                 parserInput.commentStore.length = 0;
+
                 if (hasIdentifier) {
                     value = this.entity();
                     if (!value) {
-                        error("expected ".concat(name, " identifier"));
+                        error(`expected ${name} identifier`);
                     }
-                }
-                else if (hasExpression) {
+                } else if (hasExpression) {
                     value = this.expression();
                     if (!value) {
-                        error("expected ".concat(name, " expression"));
+                        error(`expected ${name} expression`);
                     }
-                }
-                else if (hasUnknown) {
-                    var unknownPackage = this.atruleUnknown(value, name, hasBlock);
+                } else if (hasUnknown) {
+                    const unknownPackage = this.atruleUnknown(value, name, hasBlock);
                     value = unknownPackage[0];
                     hasBlock = unknownPackage[1];
                 }
+                    
                 if (hasBlock) {
-                    var blockPackage = this.atruleBlock(rules, value, isRooted, isKeywordList);
+                    let blockPackage = this.atruleBlock(rules, value, isRooted, isKeywordList);
                     rules = blockPackage[0];
                     value = blockPackage[1];
                     isKeywordList = blockPackage[2];
+
                     if (!rules && !hasUnknown) {
                         parserInput.restore();
                         name = parserInput.$re(/^@[a-z-]+/);
-                        var unknownPackage = this.atruleUnknown(value, name, hasBlock);
+                        const unknownPackage = this.atruleUnknown(value, name, hasBlock);
                         value = unknownPackage[0];
                         hasBlock = unknownPackage[1];
                         if (hasBlock) {
@@ -2040,12 +2207,18 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         }
                     }
                 }
+
                 if (rules || isKeywordList || (!hasBlock && value && parserInput.$char(';'))) {
                     parserInput.forget();
-                    return new (tree_1.default.AtRule)(name, value, rules, index + currentIndex, fileInfo, context.dumpLineNumbers ? getDebugInfo(index) : null, isRooted);
+                    return new(tree.AtRule)(name, value, rules, index + currentIndex, fileInfo,
+                        context.dumpLineNumbers ? getDebugInfo(index) : null,
+                        isRooted
+                    );
                 }
+
                 parserInput.restore('at-rule options not recognised');
             },
+
             //
             // A Value is a comma-delimited list of Expressions
             //
@@ -2055,20 +2228,20 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             // and before the `;`.
             //
             value: function () {
-                var e;
-                var expressions = [];
-                var index = parserInput.i;
+                let e;
+                const expressions = [];
+                const index = parserInput.i;
+
                 do {
                     e = this.expression();
                     if (e) {
                         expressions.push(e);
-                        if (!parserInput.$char(',')) {
-                            break;
-                        }
+                        if (!parserInput.$char(',')) { break; }
                     }
                 } while (e);
+
                 if (expressions.length > 0) {
-                    return new (tree_1.default.Value)(expressions, index + currentIndex);
+                    return new(tree.Value)(expressions, index + currentIndex);
                 }
             },
             important: function () {
@@ -2077,14 +2250,15 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 }
             },
             sub: function () {
-                var a;
-                var e;
+                let a;
+                let e;
+
                 parserInput.save();
                 if (parserInput.$char('(')) {
                     a = this.addition();
                     if (a && parserInput.$char(')')) {
                         parserInput.forget();
-                        e = new (tree_1.default.Expression)([a]);
+                        e = new(tree.Expression)([a]);
                         e.parens = true;
                         return e;
                     }
@@ -2095,19 +2269,22 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             },
             colorOperand: function () {
                 parserInput.save();
+
                 // hsl or rgb or lch operand
-                var match = parserInput.$re(/^[lchrgbs]\s+/);
+                const match = parserInput.$re(/^[lchrgbs]\s+/);
                 if (match) {
-                    return new tree_1.default.Keyword(match[0]);
+                    parserInput.forget();
+                    return new tree.Keyword(match[0]);
                 }
+
                 parserInput.restore();
             },
             multiplication: function () {
-                var m;
-                var a;
-                var op;
-                var operation;
-                var isSpaced;
+                let m;
+                let a;
+                let op;
+                let operation;
+                let isSpaced;
                 m = this.operand();
                 if (m) {
                     isSpaced = parserInput.isWhitespace(-1);
@@ -2115,39 +2292,39 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         if (parserInput.peek(/^\/[*/]/)) {
                             break;
                         }
+
                         parserInput.save();
+
                         op = parserInput.$char('/') || parserInput.$char('*');
                         if (!op) {
-                            var index = parserInput.i;
+                            let index = parserInput.i;
                             op = parserInput.$str('./');
                             if (op) {
-                                warn('./ operator is deprecated', index, 'DEPRECATED');
+                                warn('./ operator is deprecated', index, 'DEPRECATED', 'dot-slash-operator');
                             }
                         }
-                        if (!op) {
-                            parserInput.forget();
-                            break;
-                        }
+
+                        if (!op) { parserInput.forget(); break; }
+
                         a = this.operand();
-                        if (!a) {
-                            parserInput.restore();
-                            break;
-                        }
+
+                        if (!a) { parserInput.restore(); break; }
                         parserInput.forget();
+
                         m.parensInOp = true;
                         a.parensInOp = true;
-                        operation = new (tree_1.default.Operation)(op, [operation || m, a], isSpaced);
+                        operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
                         isSpaced = parserInput.isWhitespace(-1);
                     }
                     return operation || m;
                 }
             },
             addition: function () {
-                var m;
-                var a;
-                var op;
-                var operation;
-                var isSpaced;
+                let m;
+                let a;
+                let op;
+                let operation;
+                let isSpaced;
                 m = this.multiplication();
                 if (m) {
                     isSpaced = parserInput.isWhitespace(-1);
@@ -2160,19 +2337,21 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         if (!a) {
                             break;
                         }
+
                         m.parensInOp = true;
                         a.parensInOp = true;
-                        operation = new (tree_1.default.Operation)(op, [operation || m, a], isSpaced);
+                        operation = new(tree.Operation)(op, [operation || m, a], isSpaced);
                         isSpaced = parserInput.isWhitespace(-1);
                     }
                     return operation || m;
                 }
             },
             conditions: function () {
-                var a;
-                var b;
-                var index = parserInput.i;
-                var condition;
+                let a;
+                let b;
+                const index = parserInput.i;
+                let condition;
+
                 a = this.condition(true);
                 if (a) {
                     while (true) {
@@ -2183,41 +2362,41 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         if (!b) {
                             break;
                         }
-                        condition = new (tree_1.default.Condition)('or', condition || a, b, index + currentIndex);
+                        condition = new(tree.Condition)('or', condition || a, b, index + currentIndex);
                     }
                     return condition || a;
                 }
             },
             condition: function (needsParens) {
-                var result;
-                var logical;
-                var next;
+                let result;
+                let logical;
+                let next;
                 function or() {
                     return parserInput.$str('or');
                 }
+
                 result = this.conditionAnd(needsParens);
                 if (!result) {
-                    return;
+                    return ;
                 }
                 logical = or();
                 if (logical) {
                     next = this.condition(needsParens);
                     if (next) {
-                        result = new (tree_1.default.Condition)(logical, result, next);
-                    }
-                    else {
-                        return;
+                        result = new(tree.Condition)(logical, result, next);
+                    } else {
+                        return ;
                     }
                 }
                 return result;
             },
             conditionAnd: function (needsParens) {
-                var result;
-                var logical;
-                var next;
-                var self = this;
+                let result;
+                let logical;
+                let next;
+                const self = this;
                 function insideCondition() {
-                    var cond = self.negatedCondition(needsParens) || self.parenthesisCondition(needsParens);
+                    const cond = self.negatedCondition(needsParens) || self.parenthesisCondition(needsParens);
                     if (!cond && !needsParens) {
                         return self.atomicCondition(needsParens);
                     }
@@ -2226,25 +2405,25 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 function and() {
                     return parserInput.$str('and');
                 }
+
                 result = insideCondition();
                 if (!result) {
-                    return;
+                    return ;
                 }
                 logical = and();
                 if (logical) {
                     next = this.conditionAnd(needsParens);
                     if (next) {
-                        result = new (tree_1.default.Condition)(logical, result, next);
-                    }
-                    else {
-                        return;
+                        result = new(tree.Condition)(logical, result, next);
+                    } else {
+                        return ;
                     }
                 }
                 return result;
             },
             negatedCondition: function (needsParens) {
                 if (parserInput.$str('not')) {
-                    var result = this.parenthesisCondition(needsParens);
+                    const result = this.parenthesisCondition(needsParens);
                     if (result) {
                         result.negate = !result.negate;
                     }
@@ -2253,123 +2432,127 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             },
             parenthesisCondition: function (needsParens) {
                 function tryConditionFollowedByParenthesis(me) {
-                    var body;
+                    let body;
                     parserInput.save();
                     body = me.condition(needsParens);
                     if (!body) {
                         parserInput.restore();
-                        return;
+                        return ;
                     }
                     if (!parserInput.$char(')')) {
                         parserInput.restore();
-                        return;
+                        return ;
                     }
                     parserInput.forget();
                     return body;
                 }
-                var body;
+
+                let body;
                 parserInput.save();
                 if (!parserInput.$str('(')) {
                     parserInput.restore();
-                    return;
+                    return ;
                 }
                 body = tryConditionFollowedByParenthesis(this);
                 if (body) {
                     parserInput.forget();
                     return body;
                 }
+
                 body = this.atomicCondition(needsParens);
                 if (!body) {
                     parserInput.restore();
-                    return;
+                    return ;
                 }
                 if (!parserInput.$char(')')) {
-                    parserInput.restore("expected ')' got '".concat(parserInput.currentChar(), "'"));
-                    return;
+                    parserInput.restore(`expected ')' got '${parserInput.currentChar()}'`);
+                    return ;
                 }
                 parserInput.forget();
                 return body;
             },
             atomicCondition: function (needsParens, preparsedCond) {
-                var entities = this.entities;
-                var index = parserInput.i;
-                var a;
-                var b;
-                var c;
-                var op;
-                var cond = (function () {
+                const entities = this.entities;
+                const index = parserInput.i;
+                let a;
+                let b;
+                let c;
+                let op;
+
+                const cond = (function() {
                     return this.addition() || entities.keyword() || entities.quoted() || entities.mixinLookup();
-                }).bind(this);
+                }).bind(this)
+
                 if (preparsedCond) {
                     a = preparsedCond;
-                }
-                else {
+                } else {
                     a = cond();
                 }
+
                 if (a) {
                     if (parserInput.$char('>')) {
                         if (parserInput.$char('=')) {
                             op = '>=';
-                        }
-                        else {
+                        } else {
                             op = '>';
                         }
-                    }
-                    else if (parserInput.$char('<')) {
+                    } else
+                    if (parserInput.$char('<')) {
                         if (parserInput.$char('=')) {
                             op = '<=';
-                        }
-                        else {
+                        } else {
                             op = '<';
                         }
-                    }
-                    else if (parserInput.$char('=')) {
+                    } else
+                    if (parserInput.$char('=')) {
                         if (parserInput.$char('>')) {
                             op = '=>';
-                        }
-                        else if (parserInput.$char('<')) {
+                        } else if (parserInput.$char('<')) {
                             op = '=<';
-                        }
-                        else {
+                        } else {
                             op = '=';
                         }
                     }
                     if (op) {
                         b = cond();
                         if (b) {
-                            c = new (tree_1.default.Condition)(op, a, b, index + currentIndex, false);
-                        }
-                        else {
+                            c = new(tree.Condition)(op, a, b, index + currentIndex, false);
+                        } else {
                             error('expected expression');
                         }
-                    }
-                    else if (!preparsedCond) {
-                        c = new (tree_1.default.Condition)('=', a, new (tree_1.default.Keyword)('true'), index + currentIndex, false);
+                    } else if (!preparsedCond) {
+                        c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index + currentIndex, false);
                     }
                     return c;
                 }
             },
+
             //
             // An operand is anything that can be part of an operation,
             // such as a Color, or a Variable
             //
             operand: function () {
-                var entities = this.entities;
-                var negate;
+                const entities = this.entities;
+                let negate;
+
                 if (parserInput.peek(/^-[@$(]/)) {
                     negate = parserInput.$char('-');
                 }
-                var o = this.sub() || entities.dimension() ||
-                    entities.color() || entities.variable() ||
-                    entities.property() || entities.call() ||
-                    entities.quoted(true) || entities.colorKeyword() ||
-                    this.colorOperand() || entities.mixinLookup();
+
+                let o = this.sub() || entities.dimension() ||
+                        entities.color() || entities.variable() ||
+                        entities.property() || entities.call() ||
+                        entities.quoted(true) || entities.colorKeyword() ||
+                        this.colorOperand() || entities.mixinLookup();
+
                 if (negate) {
                     o.parensInOp = true;
-                    o = new (tree_1.default.Negative)(o);
+                    o = new(tree.Negative)(o);
                 }
+
                 return o;
             },
+
             //
             // Expressions either represent mathematical operations,
             // or white-space delimited Entities.
@@ -2378,10 +2561,11 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
             //     @var * 2
             //
             expression: function () {
-                var entities = [];
-                var e;
-                var delim;
-                var index = parserInput.i;
+                const entities = [];
+                let e;
+                let delim;
+                const index = parserInput.i;
+
                 do {
                     e = this.comment();
                     if (e && !e.isLineComment) {
@@ -2389,58 +2573,66 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         continue;
                     }
                     e = this.addition() || this.entity();
-                    if (e instanceof tree_1.default.Comment) {
+
+                    if (e instanceof tree.Comment) {
                         e = null;
                     }
+
                     if (e) {
                         entities.push(e);
                         // operations do not allow keyword "/" dimension (e.g. small/20px) so we support that here
                         if (!parserInput.peek(/^\/[/*]/)) {
                             delim = parserInput.$char('/');
                             if (delim) {
-                                entities.push(new (tree_1.default.Anonymous)(delim, index + currentIndex));
+                                entities.push(new(tree.Anonymous)(delim, index + currentIndex));
                             }
                         }
                     }
                 } while (e);
                 if (entities.length > 0) {
-                    return new (tree_1.default.Expression)(entities);
+                    return new(tree.Expression)(entities);
                 }
             },
             property: function () {
-                var name = parserInput.$re(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/);
+                const name = parserInput.$re(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/);
                 if (name) {
                     return name[1];
                 }
             },
             ruleProperty: function () {
-                var name = [];
-                var index = [];
-                var s;
-                var k;
+                let name = [];
+                const index = [];
+                let s;
+                let k;
+
                 parserInput.save();
-                var simpleProperty = parserInput.$re(/^([_a-zA-Z0-9-]+)\s*:/);
+
+                const simpleProperty = parserInput.$re(/^([_a-zA-Z0-9-]+)\s*:/);
                 if (simpleProperty) {
-                    name = [new (tree_1.default.Keyword)(simpleProperty[1])];
+                    name = [new(tree.Keyword)(simpleProperty[1])];
                     parserInput.forget();
                     return name;
                 }
+
                 function match(re) {
-                    var i = parserInput.i;
-                    var chunk = parserInput.$re(re);
+                    const i = parserInput.i;
+                    const chunk = parserInput.$re(re);
                     if (chunk) {
                         index.push(i);
                         return name.push(chunk[1]);
                     }
                 }
+
                 match(/^(\*?)/);
                 while (true) {
                     if (!match(/^((?:[\w-]+)|(?:[@$]\{[\w-]+\}))/)) {
                         break;
                     }
                 }
+
                 if ((name.length > 1) && match(/^((?:\+_|\+)?)\s*:/)) {
                     parserInput.forget();
+
                     // at last, we have the complete match now. move forward,
                     // convert name particles to tree objects and return:
                     if (name[0] === '') {
@@ -2450,10 +2642,10 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     for (k = 0; k < name.length; k++) {
                         s = name[k];
                         name[k] = (s.charAt(0) !== '@' && s.charAt(0) !== '$') ?
-                            new (tree_1.default.Keyword)(s) :
+                            new(tree.Keyword)(s) :
                             (s.charAt(0) === '@' ?
-                                new (tree_1.default.Variable)("@".concat(s.slice(2, -1)), index[k] + currentIndex, fileInfo) :
-                                new (tree_1.default.Property)("$".concat(s.slice(2, -1)), index[k] + currentIndex, fileInfo));
+                                new(tree.Variable)(`@${s.slice(2, -1)}`, index[k] + currentIndex, fileInfo) :
+                                new(tree.Property)(`$${s.slice(2, -1)}`, index[k] + currentIndex, fileInfo));
                     }
                     return name;
                 }
@@ -2462,15 +2654,17 @@ var Parser = function Parser(context, imports, fileInfo, currentIndex) {
         }
     };
 };
-Parser.serializeVars = function (vars) {
-    var s = '';
-    for (var name_1 in vars) {
-        if (Object.hasOwnProperty.call(vars, name_1)) {
-            var value = vars[name_1];
-            s += "".concat(((name_1[0] === '@') ? '' : '@') + name_1, ": ").concat(value).concat((String(value).slice(-1) === ';') ? '' : ';');
+Parser.serializeVars = vars => {
+    let s = '';
+
+    for (const name in vars) {
+        if (Object.hasOwnProperty.call(vars, name)) {
+            const value = vars[name];
+            s += `${((name[0] === '@') ? '' : '@') + name}: ${value}${(String(value).slice(-1) === ';') ? '' : ';'}`;
         }
     }
+
     return s;
 };
-exports.default = Parser;
-//# sourceMappingURL=parser.js.map
+
+export default Parser;