less 4.2.2 → 4.3.0

package/dist/less.js

@@ -1,5 +1,5 @@
 /**
- * Less - Leaner CSS v4.2.2
+ * Less - Leaner CSS v4.3.0
  * http://lesscss.org
  * 
  * Copyright (c) 2009-2025, Alexis Sellier <self@cloudhead.net>
@@ -856,6 +856,47 @@
         }).join(''));
     }
 
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    var __assign = function() {
+      __assign = Object.assign || function __assign(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments[i];
+              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+          }
+          return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+
+    function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+              if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+              ar[i] = from[i];
+          }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
     var Paren = function (node) {
         this.value = node;
     };
@@ -962,47 +1003,6 @@
         ALL: 2
     };
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign = function() {
-      __assign = Object.assign || function __assign(t) {
-          for (var s, i = 1, n = arguments.length; i < n; i++) {
-              s = arguments[i];
-              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-          }
-          return t;
-      };
-      return __assign.apply(this, arguments);
-    };
-
-    function __spreadArray(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-          if (ar || !(i in from)) {
-              if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-              ar[i] = from[i];
-          }
-      }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-      var e = new Error(message);
-      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
     /**
      * Returns the object type of the given payload
      *
@@ -1034,7 +1034,7 @@
     }
 
     function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
-        var propType = {}.propertyIsEnumerable.call(originalObject, key)
+        const propType = {}.propertyIsEnumerable.call(originalObject, key)
             ? 'enumerable'
             : 'nonenumerable';
         if (propType === 'enumerable')
@@ -1058,22 +1058,21 @@
      * @returns {T} the target with replaced values
      * @export
      */
-    function copy(target, options) {
-        if (options === void 0) { options = {}; }
+    function copy(target, options = {}) {
         if (isArray(target)) {
-            return target.map(function (item) { return copy(item, options); });
+            return target.map((item) => copy(item, options));
         }
         if (!isPlainObject(target)) {
             return target;
         }
-        var props = Object.getOwnPropertyNames(target);
-        var symbols = Object.getOwnPropertySymbols(target);
-        return __spreadArray(__spreadArray([], props, true), symbols, true).reduce(function (carry, key) {
+        const props = Object.getOwnPropertyNames(target);
+        const symbols = Object.getOwnPropertySymbols(target);
+        return [...props, ...symbols].reduce((carry, key) => {
             if (isArray(options.props) && !options.props.includes(key)) {
                 return carry;
             }
-            var val = target[key];
-            var newVal = copy(val, options);
+            const val = target[key];
+            const newVal = copy(val, options);
             assignProp(carry, key, newVal, target, options.nonenumerable);
             return carry;
         }, {});
@@ -1299,20 +1298,24 @@
      * @returns {string}
      */
     LessError.prototype.toString = function (options) {
+        var _a;
         options = options || {};
+        var isWarning = ((_a = this.type) !== null && _a !== void 0 ? _a : '').toLowerCase().includes('warning');
+        var type = isWarning ? this.type : "".concat(this.type, "Error");
+        var color = isWarning ? 'yellow' : 'red';
         var message = '';
         var extract = this.extract || [];
         var error = [];
         var stylize = function (str) { return str; };
         if (options.stylize) {
-            var type = typeof options.stylize;
-            if (type !== 'function') {
-                throw Error("options.stylize should be a function, got a ".concat(type, "!"));
+            var type_1 = typeof options.stylize;
+            if (type_1 !== 'function') {
+                throw Error("options.stylize should be a function, got a ".concat(type_1, "!"));
             }
             stylize = options.stylize;
         }
         if (this.line !== null) {
-            if (typeof extract[0] === 'string') {
+            if (!isWarning && typeof extract[0] === 'string') {
                 error.push(stylize("".concat(this.line - 1, " ").concat(extract[0]), 'grey'));
             }
             if (typeof extract[1] === 'string') {
@@ -1324,21 +1327,21 @@
                 }
                 error.push(errorTxt);
             }
-            if (typeof extract[2] === 'string') {
+            if (!isWarning && typeof extract[2] === 'string') {
                 error.push(stylize("".concat(this.line + 1, " ").concat(extract[2]), 'grey'));
             }
             error = "".concat(error.join('\n') + stylize('', 'reset'), "\n");
         }
-        message += stylize("".concat(this.type, "Error: ").concat(this.message), 'red');
+        message += stylize("".concat(type, ": ").concat(this.message), color);
         if (this.filename) {
-            message += stylize(' in ', 'red') + this.filename;
+            message += stylize(' in ', color) + this.filename;
         }
         if (this.line) {
             message += stylize(" on line ".concat(this.line, ", column ").concat(this.column + 1, ":"), 'grey');
         }
         message += "\n".concat(error);
         if (this.callLine) {
-            message += "".concat(stylize('from ', 'red') + (this.filename || ''), "/n");
+            message += "".concat(stylize('from ', color) + (this.filename || ''), "/n");
             message += "".concat(stylize(this.callLine, 'grey'), " ").concat(this.callExtract, "/n");
         }
         return message;
@@ -1519,7 +1522,8 @@
         // context
         'processImports',
         // Used by the import manager to stop multiple import visitors being created.
-        'pluginManager' // Used as the plugin manager for the session
+        'pluginManager',
+        'quiet', // option - whether to log warnings
     ];
     contexts.Parse = function (options) {
         copyFromOriginal(options, this, parseCopyProperties);
@@ -1830,7 +1834,20 @@
             }
         },
         visitAtRule: function (atRuleNode, visitArgs) {
-            this.context.frames.unshift(atRuleNode);
+            if (atRuleNode.value) {
+                this.context.frames.unshift(atRuleNode);
+            }
+            else if (atRuleNode.declarations && atRuleNode.declarations.length) {
+                if (atRuleNode.isRooted) {
+                    this.context.frames.unshift(atRuleNode);
+                }
+                else {
+                    this.context.frames.unshift(atRuleNode.declarations[0]);
+                }
+            }
+            else if (atRuleNode.rules && atRuleNode.rules.length) {
+                this.context.frames.unshift(atRuleNode);
+            }
         },
         visitAtRuleOut: function (atRuleNode) {
             this.context.frames.shift();
@@ -2006,7 +2023,12 @@
                 catch (_) { }
                 if (!indices["".concat(extend.index, " ").concat(selector)]) {
                     indices["".concat(extend.index, " ").concat(selector)] = true;
-                    logger$1.warn("extend '".concat(selector, "' has no matches"));
+                    /**
+                     * @todo Shouldn't this be an error? To alert the developer
+                     * that they may have made an error in the selector they are
+                     * targeting?
+                     */
+                    logger$1.warn("WARNING: extend '".concat(selector, "' has no matches"));
                 }
             });
         };
@@ -2367,7 +2389,10 @@
         };
         JoinSelectorVisitor.prototype.visitAtRule = function (atRuleNode, visitArgs) {
             var context = this.contexts[this.contexts.length - 1];
-            if (atRuleNode.rules && atRuleNode.rules.length) {
+            if (atRuleNode.declarations && atRuleNode.declarations.length) {
+                atRuleNode.declarations[0].root = (context.length === 0 || context[0].multiMedia);
+            }
+            else if (atRuleNode.rules && atRuleNode.rules.length) {
                 atRuleNode.rules[0].root = (atRuleNode.isRooted || context.length === 0 || null);
             }
         };
@@ -3310,6 +3335,22 @@
                 message: msg
             }, imports);
         }
+        /**
+         *
+         * @param {string} msg
+         * @param {number} index
+         * @param {string} type
+         */
+        function warn(msg, index, type) {
+            if (!context.quiet) {
+                logger$1.warn((new LessError({
+                    index: index !== null && index !== void 0 ? index : parserInput.i,
+                    filename: fileInfo.filename,
+                    type: type ? "".concat(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);
@@ -4017,11 +4058,20 @@
                     do {
                         option = null;
                         elements = null;
-                        while (!(option = parserInput.$re(/^(all)(?=\s*(\)|,))/))) {
+                        var first = true;
+                        while (!(option = parserInput.$re(/^(!?all)(?=\s*(\)|,))/))) {
                             e = this.element();
                             if (!e) {
                                 break;
                             }
+                            /**
+                             * @note - This will not catch selectors in pseudos like :is() and :where() because
+                             * 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);
+                            }
+                            first = false;
                             if (elements) {
                                 elements.push(e);
                             }
@@ -4081,16 +4131,23 @@
                         var elements;
                         var args;
                         var hasParens;
+                        var parensIndex;
+                        var 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);
                                 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');
+                                }
                             }
                             if (getLookup !== false) {
                                 lookups = this.ruleLookups();
@@ -4114,6 +4171,9 @@
                                     return new tree.NamespaceValue(mixin, lookups);
                                 }
                                 else {
+                                    if (!hasParens) {
+                                        warn('Calling a mixin without parentheses is deprecated', parensIndex, 'DEPRECATED');
+                                    }
                                     return mixin;
                                 }
                             }
@@ -4403,24 +4463,25 @@
                     expectChar(')');
                     return new tree.Quoted('', "alpha(opacity=".concat(value, ")"));
                 },
-                //
-                // A Selector Element
-                //
-                //     div
-                //     + h1
-                //     #socks
-                //     input[type="text"]
-                //
-                // Elements are the building blocks for Selectors,
-                // they are made out of a `Combinator` (see combinator rule),
-                // and an element name, such as a tag a class, or `*`.
-                //
+                /**
+                 * A Selector Element
+                 *
+                 *   div
+                 *   + h1
+                 *   #socks
+                 *   input[type="text"]
+                 *
+                 * Elements are the building blocks for Selectors,
+                 * they are made out of a `Combinator` (see combinator rule),
+                 * and an element name, such as a tag a class, or `*`.
+                 */
                 element: function () {
                     var e;
                     var c;
                     var v;
                     var 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]))+/) ||
@@ -4721,7 +4782,7 @@
                                     value = new Anonymous('');
                                 }
                                 else {
-                                    value = this.permissiveValue(/[;}]/);
+                                    value = this.permissiveValue(/[;}]/, true);
                                 }
                             }
                             // Try to store values as anonymous
@@ -4741,7 +4802,12 @@
                                 important = this.important();
                             }
                             else if (isVariable) {
-                                // As a last resort, try permissiveValue
+                                /**
+                                 * As a last resort, try permissiveValue
+                                 *
+                                 * @todo - This has created some knock-on problems of not
+                                 * flagging incorrect syntax or detecting user intent.
+                                 */
                                 value = this.permissiveValue();
                             }
                         }
@@ -4772,6 +4838,8 @@
                  * 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;
@@ -4833,6 +4901,7 @@
                             parserInput.forget();
                             return new tree.Anonymous('', index);
                         }
+                        /** @type {string} */
                         var item = void 0;
                         for (i = 0; i < value.length; i++) {
                             item = value[i];
@@ -4846,10 +4915,16 @@
                                 }
                                 // Treat like quoted values, but replace vars like unquoted expressions
                                 var quote = new tree.Quoted('\'', item, true, index, fileInfo);
-                                if (!item.startsWith('@{')) {
-                                    quote.variableRegex = /@([\w-]+)/g;
+                                var variableRegex = /@([\w-]+)/g;
+                                var 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');
                                 }
-                                quote.propRegex = /\$([\w-]+)/g;
+                                if (propRegex.test(item)) {
+                                    warn('$[ident] in unknown values will not be evaluated as property references in the future. Use ${[ident]}', index, 'DEPRECATED');
+                                }
+                                quote.variableRegex = /@([\w-]+)|@{([\w-]+)}/g;
+                                quote.propRegex = /\$([\w-]+)|\${([\w-]+)}/g;
                                 result.push(quote);
                             }
                         }
@@ -5138,6 +5213,9 @@
                             hasUnknown = true;
                             isRooted = false;
                             break;
+                        case '@starting-style':
+                            isRooted = false;
+                            break;
                         default:
                             hasUnknown = true;
                             break;
@@ -5237,7 +5315,14 @@
                                 break;
                             }
                             parserInput.save();
-                            op = parserInput.$char('/') || parserInput.$char('*') || parserInput.$str('./');
+                            op = parserInput.$char('/') || parserInput.$char('*');
+                            if (!op) {
+                                var index = parserInput.i;
+                                op = parserInput.$str('./');
+                                if (op) {
+                                    warn('./ operator is deprecated', index, 'DEPRECATED');
+                                }
+                            }
                             if (!op) {
                                 parserInput.forget();
                                 break;
@@ -6654,153 +6739,6 @@
         }
     });
 
-    var AtRule = function (name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
-        var i;
-        this.name = name;
-        this.value = (value instanceof Node) ? value : (value ? new Anonymous(value) : value);
-        if (rules) {
-            if (Array.isArray(rules)) {
-                this.rules = rules;
-            }
-            else {
-                this.rules = [rules];
-                this.rules[0].selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
-            }
-            for (i = 0; i < this.rules.length; i++) {
-                this.rules[i].allowImports = true;
-            }
-            this.setParent(this.rules, this);
-        }
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        this.debugInfo = debugInfo;
-        this.isRooted = isRooted || false;
-        this.copyVisibilityInfo(visibilityInfo);
-        this.allowRoot = true;
-    };
-    AtRule.prototype = Object.assign(new Node(), {
-        type: 'AtRule',
-        accept: function (visitor) {
-            var value = this.value, rules = this.rules;
-            if (rules) {
-                this.rules = visitor.visitArray(rules);
-            }
-            if (value) {
-                this.value = visitor.visit(value);
-            }
-        },
-        isRulesetLike: function () {
-            return this.rules || !this.isCharset();
-        },
-        isCharset: function () {
-            return '@charset' === this.name;
-        },
-        genCSS: function (context, output) {
-            var value = this.value, rules = this.rules;
-            output.add(this.name, this.fileInfo(), this.getIndex());
-            if (value) {
-                output.add(' ');
-                value.genCSS(context, output);
-            }
-            if (rules) {
-                this.outputRuleset(context, output, rules);
-            }
-            else {
-                output.add(';');
-            }
-        },
-        eval: function (context) {
-            var mediaPathBackup, mediaBlocksBackup, value = this.value, rules = this.rules;
-            // media stored inside other atrule should not bubble over it
-            // backpup media bubbling information
-            mediaPathBackup = context.mediaPath;
-            mediaBlocksBackup = context.mediaBlocks;
-            // deleted media bubbling information
-            context.mediaPath = [];
-            context.mediaBlocks = [];
-            if (value) {
-                value = value.eval(context);
-            }
-            if (rules) {
-                // assuming that there is only one rule at this point - that is how parser constructs the rule
-                rules = [rules[0].eval(context)];
-                rules[0].root = true;
-            }
-            // restore media bubbling information
-            context.mediaPath = mediaPathBackup;
-            context.mediaBlocks = mediaBlocksBackup;
-            return new AtRule(this.name, value, rules, this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
-        },
-        variable: function (name) {
-            if (this.rules) {
-                // assuming that there is only one rule at this point - that is how parser constructs the rule
-                return Ruleset.prototype.variable.call(this.rules[0], name);
-            }
-        },
-        find: function () {
-            if (this.rules) {
-                // assuming that there is only one rule at this point - that is how parser constructs the rule
-                return Ruleset.prototype.find.apply(this.rules[0], arguments);
-            }
-        },
-        rulesets: function () {
-            if (this.rules) {
-                // assuming that there is only one rule at this point - that is how parser constructs the rule
-                return Ruleset.prototype.rulesets.apply(this.rules[0]);
-            }
-        },
-        outputRuleset: function (context, output, rules) {
-            var ruleCnt = rules.length;
-            var i;
-            context.tabLevel = (context.tabLevel | 0) + 1;
-            // Compressed
-            if (context.compress) {
-                output.add('{');
-                for (i = 0; i < ruleCnt; i++) {
-                    rules[i].genCSS(context, output);
-                }
-                output.add('}');
-                context.tabLevel--;
-                return;
-            }
-            // Non-compressed
-            var tabSetStr = "\n".concat(Array(context.tabLevel).join('  ')), tabRuleStr = "".concat(tabSetStr, "  ");
-            if (!ruleCnt) {
-                output.add(" {".concat(tabSetStr, "}"));
-            }
-            else {
-                output.add(" {".concat(tabRuleStr));
-                rules[0].genCSS(context, output);
-                for (i = 1; i < ruleCnt; i++) {
-                    output.add(tabRuleStr);
-                    rules[i].genCSS(context, output);
-                }
-                output.add("".concat(tabSetStr, "}"));
-            }
-            context.tabLevel--;
-        }
-    });
-
-    var DetachedRuleset = function (ruleset, frames) {
-        this.ruleset = ruleset;
-        this.frames = frames;
-        this.setParent(this.ruleset, this);
-    };
-    DetachedRuleset.prototype = Object.assign(new Node(), {
-        type: 'DetachedRuleset',
-        evalFirst: true,
-        accept: function (visitor) {
-            this.ruleset = visitor.visit(this.ruleset);
-        },
-        eval: function (context) {
-            var frames = this.frames || copyArray(context.frames);
-            return new DetachedRuleset(this.ruleset, frames);
-        },
-        callEval: function (context) {
-            return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
-        }
-    });
-
     var Unit = function (numerator, denominator, backupUnit) {
         this.numerator = numerator ? copyArray(numerator).sort() : [];
         this.denominator = denominator ? copyArray(denominator).sort() : [];
@@ -7065,54 +7003,6 @@
         }
     });
 
-    var MATH = Math$1;
-    var Operation = function (op, operands, isSpaced) {
-        this.op = op.trim();
-        this.operands = operands;
-        this.isSpaced = isSpaced;
-    };
-    Operation.prototype = Object.assign(new Node(), {
-        type: 'Operation',
-        accept: function (visitor) {
-            this.operands = visitor.visitArray(this.operands);
-        },
-        eval: function (context) {
-            var a = this.operands[0].eval(context), b = this.operands[1].eval(context), op;
-            if (context.isMathOn(this.op)) {
-                op = this.op === './' ? '/' : this.op;
-                if (a instanceof Dimension && b instanceof Color) {
-                    a = a.toColor();
-                }
-                if (b instanceof Dimension && a instanceof Color) {
-                    b = b.toColor();
-                }
-                if (!a.operate || !b.operate) {
-                    if ((a instanceof Operation || b instanceof Operation)
-                        && a.op === '/' && context.math === MATH.PARENS_DIVISION) {
-                        return new Operation(this.op, [a, b], this.isSpaced);
-                    }
-                    throw { type: 'Operation',
-                        message: 'Operation on an invalid type' };
-                }
-                return a.operate(context, op, b);
-            }
-            else {
-                return new Operation(this.op, [a, b], this.isSpaced);
-            }
-        },
-        genCSS: function (context, output) {
-            this.operands[0].genCSS(context, output);
-            if (this.isSpaced) {
-                output.add(' ');
-            }
-            output.add(this.op);
-            if (this.isSpaced) {
-                output.add(' ');
-            }
-            this.operands[1].genCSS(context, output);
-        }
-    });
-
     var Expression = function (value, noSpacing) {
         this.value = value;
         this.noSpacing = noSpacing;
@@ -7177,6 +7067,373 @@
         }
     });
 
+    var NestableAtRulePrototype = {
+        isRulesetLike: function () {
+            return true;
+        },
+        accept: function (visitor) {
+            if (this.features) {
+                this.features = visitor.visit(this.features);
+            }
+            if (this.rules) {
+                this.rules = visitor.visitArray(this.rules);
+            }
+        },
+        evalTop: function (context) {
+            var result = this;
+            // Render all dependent Media blocks.
+            if (context.mediaBlocks.length > 1) {
+                var selectors = (new Selector([], null, null, this.getIndex(), this.fileInfo())).createEmptySelectors();
+                result = new Ruleset(selectors, context.mediaBlocks);
+                result.multiMedia = true;
+                result.copyVisibilityInfo(this.visibilityInfo());
+                this.setParent(result, this);
+            }
+            delete context.mediaBlocks;
+            delete context.mediaPath;
+            return result;
+        },
+        evalNested: function (context) {
+            var i;
+            var value;
+            var path = context.mediaPath.concat([this]);
+            // Extract the media-query conditions separated with `,` (OR).
+            for (i = 0; i < path.length; i++) {
+                if (path[i].type !== this.type) {
+                    context.mediaBlocks.splice(i, 1);
+                    return this;
+                }
+                value = path[i].features instanceof Value ?
+                    path[i].features.value : path[i].features;
+                path[i] = Array.isArray(value) ? value : [value];
+            }
+            // Trace all permutations to generate the resulting media-query.
+            //
+            // (a, b and c) with nested (d, e) ->
+            //    a and d
+            //    a and e
+            //    b and c and d
+            //    b and c and e
+            this.features = new Value(this.permute(path).map(function (path) {
+                path = path.map(function (fragment) { return fragment.toCSS ? fragment : new Anonymous(fragment); });
+                for (i = path.length - 1; i > 0; i--) {
+                    path.splice(i, 0, new Anonymous('and'));
+                }
+                return new Expression(path);
+            }));
+            this.setParent(this.features, this);
+            // Fake a tree-node that doesn't output anything.
+            return new Ruleset([], []);
+        },
+        permute: function (arr) {
+            if (arr.length === 0) {
+                return [];
+            }
+            else if (arr.length === 1) {
+                return arr[0];
+            }
+            else {
+                var result = [];
+                var rest = this.permute(arr.slice(1));
+                for (var i_1 = 0; i_1 < rest.length; i_1++) {
+                    for (var j = 0; j < arr[0].length; j++) {
+                        result.push([arr[0][j]].concat(rest[i_1]));
+                    }
+                }
+                return result;
+            }
+        },
+        bubbleSelectors: function (selectors) {
+            if (!selectors) {
+                return;
+            }
+            this.rules = [new Ruleset(copyArray(selectors), [this.rules[0]])];
+            this.setParent(this.rules, this);
+        }
+    };
+
+    var AtRule = function (name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
+        var _this = this;
+        var i;
+        var selectors = (new Selector([], null, null, this._index, this._fileInfo)).createEmptySelectors();
+        this.name = name;
+        this.value = (value instanceof Node) ? value : (value ? new Anonymous(value) : value);
+        if (rules) {
+            if (Array.isArray(rules)) {
+                var allDeclarations = this.declarationsBlock(rules);
+                var allRulesetDeclarations_1 = true;
+                rules.forEach(function (rule) {
+                    if (rule.type === 'Ruleset' && rule.rules)
+                        allRulesetDeclarations_1 = allRulesetDeclarations_1 && _this.declarationsBlock(rule.rules, true);
+                });
+                if (allDeclarations && !isRooted) {
+                    this.simpleBlock = true;
+                    this.declarations = rules;
+                }
+                else if (allRulesetDeclarations_1 && rules.length === 1 && !isRooted && !value) {
+                    this.simpleBlock = true;
+                    this.declarations = rules[0].rules ? rules[0].rules : rules;
+                }
+                else {
+                    this.rules = rules;
+                }
+            }
+            else {
+                var allDeclarations = this.declarationsBlock(rules.rules);
+                if (allDeclarations && !isRooted && !value) {
+                    this.simpleBlock = true;
+                    this.declarations = rules.rules;
+                }
+                else {
+                    this.rules = [rules];
+                    this.rules[0].selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
+                }
+            }
+            if (!this.simpleBlock) {
+                for (i = 0; i < this.rules.length; i++) {
+                    this.rules[i].allowImports = true;
+                }
+            }
+            this.setParent(selectors, this);
+            this.setParent(this.rules, this);
+        }
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.debugInfo = debugInfo;
+        this.isRooted = isRooted || false;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+    };
+    AtRule.prototype = Object.assign(new Node(), __assign(__assign({ type: 'AtRule' }, NestableAtRulePrototype), { declarationsBlock: function (rules, mergeable) {
+            if (mergeable === void 0) { mergeable = false; }
+            if (!mergeable) {
+                return rules.filter(function (node) { return (node.type === 'Declaration' || node.type === 'Comment') && !node.merge; }).length === rules.length;
+            }
+            else {
+                return rules.filter(function (node) { return (node.type === 'Declaration' || node.type === 'Comment'); }).length === rules.length;
+            }
+        }, accept: function (visitor) {
+            var value = this.value, rules = this.rules, declarations = this.declarations;
+            if (rules) {
+                this.rules = visitor.visitArray(rules);
+            }
+            else if (declarations) {
+                this.declarations = visitor.visitArray(declarations);
+            }
+            if (value) {
+                this.value = visitor.visit(value);
+            }
+        }, isRulesetLike: function () {
+            return this.rules || !this.isCharset();
+        }, isCharset: function () {
+            return '@charset' === this.name;
+        }, genCSS: function (context, output) {
+            var value = this.value, rules = this.rules || this.declarations;
+            output.add(this.name, this.fileInfo(), this.getIndex());
+            if (value) {
+                output.add(' ');
+                value.genCSS(context, output);
+            }
+            if (this.simpleBlock) {
+                this.outputRuleset(context, output, this.declarations);
+            }
+            else if (rules) {
+                this.outputRuleset(context, output, rules);
+            }
+            else {
+                output.add(';');
+            }
+        }, eval: function (context) {
+            var mediaPathBackup, mediaBlocksBackup, value = this.value, rules = this.rules || this.declarations;
+            // media stored inside other atrule should not bubble over it
+            // backpup media bubbling information
+            mediaPathBackup = context.mediaPath;
+            mediaBlocksBackup = context.mediaBlocks;
+            // deleted media bubbling information
+            context.mediaPath = [];
+            context.mediaBlocks = [];
+            if (value) {
+                value = value.eval(context);
+            }
+            if (rules) {
+                rules = this.evalRoot(context, rules);
+            }
+            if (Array.isArray(rules) && rules[0].rules && Array.isArray(rules[0].rules) && rules[0].rules.length) {
+                var allMergeableDeclarations = this.declarationsBlock(rules[0].rules, true);
+                if (allMergeableDeclarations && !this.isRooted && !value) {
+                    var mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
+                    mergeRules(rules[0].rules);
+                    rules = rules[0].rules;
+                    rules.forEach(function (rule) { return rule.merge = false; });
+                }
+            }
+            if (this.simpleBlock && rules) {
+                rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
+                rules = rules.map(function (rule) { return rule.eval(context); });
+            }
+            // restore media bubbling information
+            context.mediaPath = mediaPathBackup;
+            context.mediaBlocks = mediaBlocksBackup;
+            return new AtRule(this.name, value, rules, this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
+        }, evalRoot: function (context, rules) {
+            var ampersandCount = 0;
+            var noAmpersandCount = 0;
+            var noAmpersands = true;
+            var allAmpersands = false;
+            if (!this.simpleBlock) {
+                rules = [rules[0].eval(context)];
+            }
+            var precedingSelectors = [];
+            if (context.frames.length > 0) {
+                var _loop_1 = function (index) {
+                    var frame = context.frames[index];
+                    if (frame.type === 'Ruleset' &&
+                        frame.rules &&
+                        frame.rules.length > 0) {
+                        if (frame && !frame.root && frame.selectors && frame.selectors.length > 0) {
+                            precedingSelectors = precedingSelectors.concat(frame.selectors);
+                        }
+                    }
+                    if (precedingSelectors.length > 0) {
+                        var value_1 = '';
+                        var output = { add: function (s) { value_1 += s; } };
+                        for (var i_1 = 0; i_1 < precedingSelectors.length; i_1++) {
+                            precedingSelectors[i_1].genCSS(context, output);
+                        }
+                        if (/^&+$/.test(value_1.replace(/\s+/g, ''))) {
+                            noAmpersands = false;
+                            noAmpersandCount++;
+                        }
+                        else {
+                            allAmpersands = false;
+                            ampersandCount++;
+                        }
+                    }
+                };
+                for (var index = 0; index < context.frames.length; index++) {
+                    _loop_1(index);
+                }
+            }
+            var mixedAmpersands = ampersandCount > 0 && noAmpersandCount > 0 && !allAmpersands && !noAmpersands;
+            if ((this.isRooted && ampersandCount > 0 && noAmpersandCount === 0 && !allAmpersands && noAmpersands)
+                || !mixedAmpersands) {
+                rules[0].root = true;
+            }
+            return rules;
+        }, variable: function (name) {
+            if (this.rules) {
+                // assuming that there is only one rule at this point - that is how parser constructs the rule
+                return Ruleset.prototype.variable.call(this.rules[0], name);
+            }
+        }, find: function () {
+            if (this.rules) {
+                // assuming that there is only one rule at this point - that is how parser constructs the rule
+                return Ruleset.prototype.find.apply(this.rules[0], arguments);
+            }
+        }, rulesets: function () {
+            if (this.rules) {
+                // assuming that there is only one rule at this point - that is how parser constructs the rule
+                return Ruleset.prototype.rulesets.apply(this.rules[0]);
+            }
+        }, outputRuleset: function (context, output, rules) {
+            var ruleCnt = rules.length;
+            var i;
+            context.tabLevel = (context.tabLevel | 0) + 1;
+            // Compressed
+            if (context.compress) {
+                output.add('{');
+                for (i = 0; i < ruleCnt; i++) {
+                    rules[i].genCSS(context, output);
+                }
+                output.add('}');
+                context.tabLevel--;
+                return;
+            }
+            // Non-compressed
+            var tabSetStr = "\n".concat(Array(context.tabLevel).join('  ')), tabRuleStr = "".concat(tabSetStr, "  ");
+            if (!ruleCnt) {
+                output.add(" {".concat(tabSetStr, "}"));
+            }
+            else {
+                output.add(" {".concat(tabRuleStr));
+                rules[0].genCSS(context, output);
+                for (i = 1; i < ruleCnt; i++) {
+                    output.add(tabRuleStr);
+                    rules[i].genCSS(context, output);
+                }
+                output.add("".concat(tabSetStr, "}"));
+            }
+            context.tabLevel--;
+        } }));
+
+    var DetachedRuleset = function (ruleset, frames) {
+        this.ruleset = ruleset;
+        this.frames = frames;
+        this.setParent(this.ruleset, this);
+    };
+    DetachedRuleset.prototype = Object.assign(new Node(), {
+        type: 'DetachedRuleset',
+        evalFirst: true,
+        accept: function (visitor) {
+            this.ruleset = visitor.visit(this.ruleset);
+        },
+        eval: function (context) {
+            var frames = this.frames || copyArray(context.frames);
+            return new DetachedRuleset(this.ruleset, frames);
+        },
+        callEval: function (context) {
+            return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
+        }
+    });
+
+    var MATH = Math$1;
+    var Operation = function (op, operands, isSpaced) {
+        this.op = op.trim();
+        this.operands = operands;
+        this.isSpaced = isSpaced;
+    };
+    Operation.prototype = Object.assign(new Node(), {
+        type: 'Operation',
+        accept: function (visitor) {
+            this.operands = visitor.visitArray(this.operands);
+        },
+        eval: function (context) {
+            var a = this.operands[0].eval(context), b = this.operands[1].eval(context), op;
+            if (context.isMathOn(this.op)) {
+                op = this.op === './' ? '/' : this.op;
+                if (a instanceof Dimension && b instanceof Color) {
+                    a = a.toColor();
+                }
+                if (b instanceof Dimension && a instanceof Color) {
+                    b = b.toColor();
+                }
+                if (!a.operate || !b.operate) {
+                    if ((a instanceof Operation || b instanceof Operation)
+                        && a.op === '/' && context.math === MATH.PARENS_DIVISION) {
+                        return new Operation(this.op, [a, b], this.isSpaced);
+                    }
+                    throw { type: 'Operation',
+                        message: 'Operation on an invalid type' };
+                }
+                return a.operate(context, op, b);
+            }
+            else {
+                return new Operation(this.op, [a, b], this.isSpaced);
+            }
+        },
+        genCSS: function (context, output) {
+            this.operands[0].genCSS(context, output);
+            if (this.isSpaced) {
+                output.add(' ');
+            }
+            output.add(this.op);
+            if (this.isSpaced) {
+                output.add(' ');
+            }
+            this.operands[1].genCSS(context, output);
+        }
+    });
+
     var functionCaller = /** @class */ (function () {
         function functionCaller(name, context, index, currentFileInfo) {
             this.name = name.toLowerCase();
@@ -7493,12 +7750,12 @@
         eval: function (context) {
             var that = this;
             var value = this.value;
-            var variableReplacement = function (_, name) {
-                var v = new Variable("@".concat(name), that.getIndex(), that.fileInfo()).eval(context, true);
+            var variableReplacement = function (_, name1, name2) {
+                var v = new Variable("@".concat(name1 !== null && name1 !== void 0 ? name1 : name2), that.getIndex(), that.fileInfo()).eval(context, true);
                 return (v instanceof Quoted) ? v.value : v.toCSS();
             };
-            var propertyReplacement = function (_, name) {
-                var v = new Property("$".concat(name), that.getIndex(), that.fileInfo()).eval(context, true);
+            var propertyReplacement = function (_, name1, name2) {
+                var v = new Property("$".concat(name1 !== null && name1 !== void 0 ? name1 : name2), that.getIndex(), that.fileInfo()).eval(context, true);
                 return (v instanceof Quoted) ? v.value : v.toCSS();
             };
             function iterativeReplace(value, regexp, replacementFnc) {
@@ -7578,91 +7835,6 @@
         }
     });
 
-    var NestableAtRulePrototype = {
-        isRulesetLike: function () {
-            return true;
-        },
-        accept: function (visitor) {
-            if (this.features) {
-                this.features = visitor.visit(this.features);
-            }
-            if (this.rules) {
-                this.rules = visitor.visitArray(this.rules);
-            }
-        },
-        evalTop: function (context) {
-            var result = this;
-            // Render all dependent Media blocks.
-            if (context.mediaBlocks.length > 1) {
-                var selectors = (new Selector([], null, null, this.getIndex(), this.fileInfo())).createEmptySelectors();
-                result = new Ruleset(selectors, context.mediaBlocks);
-                result.multiMedia = true;
-                result.copyVisibilityInfo(this.visibilityInfo());
-                this.setParent(result, this);
-            }
-            delete context.mediaBlocks;
-            delete context.mediaPath;
-            return result;
-        },
-        evalNested: function (context) {
-            var i;
-            var value;
-            var path = context.mediaPath.concat([this]);
-            // Extract the media-query conditions separated with `,` (OR).
-            for (i = 0; i < path.length; i++) {
-                if (path[i].type !== this.type) {
-                    context.mediaBlocks.splice(i, 1);
-                    return this;
-                }
-                value = path[i].features instanceof Value ?
-                    path[i].features.value : path[i].features;
-                path[i] = Array.isArray(value) ? value : [value];
-            }
-            // Trace all permutations to generate the resulting media-query.
-            //
-            // (a, b and c) with nested (d, e) ->
-            //    a and d
-            //    a and e
-            //    b and c and d
-            //    b and c and e
-            this.features = new Value(this.permute(path).map(function (path) {
-                path = path.map(function (fragment) { return fragment.toCSS ? fragment : new Anonymous(fragment); });
-                for (i = path.length - 1; i > 0; i--) {
-                    path.splice(i, 0, new Anonymous('and'));
-                }
-                return new Expression(path);
-            }));
-            this.setParent(this.features, this);
-            // Fake a tree-node that doesn't output anything.
-            return new Ruleset([], []);
-        },
-        permute: function (arr) {
-            if (arr.length === 0) {
-                return [];
-            }
-            else if (arr.length === 1) {
-                return arr[0];
-            }
-            else {
-                var result = [];
-                var rest = this.permute(arr.slice(1));
-                for (var i_1 = 0; i_1 < rest.length; i_1++) {
-                    for (var j = 0; j < arr[0].length; j++) {
-                        result.push([arr[0][j]].concat(rest[i_1]));
-                    }
-                }
-                return result;
-            }
-        },
-        bubbleSelectors: function (selectors) {
-            if (!selectors) {
-                return;
-            }
-            this.rules = [new Ruleset(copyArray(selectors), [this.rules[0]])];
-            this.setParent(this.rules, this);
-        }
-    };
-
     var Media = function (value, features, index, currentFileInfo, visibilityInfo) {
         this._index = index;
         this._fileInfo = currentFileInfo;
@@ -8140,6 +8312,7 @@
         this.copyVisibilityInfo(visibilityInfo);
         this.allowRoot = true;
         switch (option) {
+            case '!all':
             case 'all':
                 this.allowBefore = true;
                 this.allowAfter = true;
@@ -10852,22 +11025,25 @@
         return render;
     }
 
-    var version = "4.2.2";
+    var version = "4.3.0";
+
+    function parseNodeVersion(version) {
+      var match = version.match(/^v(\d{1,2})\.(\d{1,2})\.(\d{1,2})(?:-([0-9A-Za-z-.]+))?(?:\+([0-9A-Za-z-.]+))?$/); // eslint-disable-line max-len
+      if (!match) {
+        throw new Error('Unable to parse: ' + version);
+      }
+
+      var res = {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+        pre: match[4] || '',
+        build: match[5] || '',
+      };
+
+      return res;
+    }
 
-    function parseNodeVersion(version) {
-        var match = version.match(/^v(\d{1,2})\.(\d{1,2})\.(\d{1,2})(?:-([0-9A-Za-z-.]+))?(?:\+([0-9A-Za-z-.]+))?$/); // eslint-disable-line max-len
-        if (!match) {
-            throw new Error('Unable to parse: ' + version);
-        }
-        var res = {
-            major: parseInt(match[1], 10),
-            minor: parseInt(match[2], 10),
-            patch: parseInt(match[3], 10),
-            pre: match[4] || '',
-            build: match[5] || '',
-        };
-        return res;
-    }
     var parseNodeVersion_1 = parseNodeVersion;
 
     function lessRoot (environment, fileManagers) {