less 4.3.0 → 4.4.1

package/dist/less.js

@@ -1,5 +1,5 @@
 /**
- * Less - Leaner CSS v4.3.0
+ * Less - Leaner CSS v4.4.1
  * http://lesscss.org
  * 
  * Copyright (c) 2009-2025, Alexis Sellier <self@cloudhead.net>
@@ -908,7 +908,11 @@
             output.add(')');
         },
         eval: function (context) {
-            return new Paren(this.value.eval(context));
+            var paren = new Paren(this.value.eval(context));
+            if (this.noSpacing) {
+                paren.noSpacing = true;
+            }
+            return paren;
         }
     });
 
@@ -5010,8 +5014,14 @@
                     var e;
                     var p;
                     var rangeP;
+                    var spacing = false;
                     parserInput.save();
                     do {
+                        parserInput.save();
+                        if (parserInput.$re(/^[0-9a-z-]*\s+\(/)) {
+                            spacing = true;
+                        }
+                        parserInput.restore();
                         e = entities.declarationCall.bind(this)() || entities.keyword() || entities.variable() || entities.mixinLookup();
                         if (e) {
                             nodes.push(e);
@@ -5039,9 +5049,14 @@
                                 }
                                 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.Paren)(e));
+                                    spacing = false;
                                 }
                                 else {
                                     error('badly formed media feature definition');
@@ -5163,6 +5178,48 @@
                         return null;
                     }
                 },
+                atruleUnknown: function (value, name, hasBlock) {
+                    value = this.permissiveValue(/^[{;]/);
+                    hasBlock = (parserInput.currentChar() === '{');
+                    if (!value) {
+                        if (!hasBlock && parserInput.currentChar() !== ';') {
+                            error(''.concat(name, ' rule is missing block or ending semi-colon'));
+                        }
+                    }
+                    else if (!value.value) {
+                        value = null;
+                    }
+                    return [value, hasBlock];
+                },
+                atruleBlock: function (rules, value, isRooted, isKeywordList) {
+                    rules = this.blockRuleset();
+                    parserInput.save();
+                    if (!rules && !isRooted) {
+                        value = this.entity();
+                        rules = this.blockRuleset();
+                    }
+                    if (!rules && !isRooted) {
+                        parserInput.restore();
+                        var e = [];
+                        value = this.entity();
+                        while (parserInput.$char(',')) {
+                            e.push(value);
+                            value = this.entity();
+                        }
+                        if (value && e.length > 0) {
+                            e.push(value);
+                            value = e;
+                            isKeywordList = true;
+                        }
+                        else {
+                            rules = this.blockRuleset();
+                        }
+                    }
+                    else {
+                        parserInput.forget();
+                    }
+                    return [rules, value, isKeywordList];
+                },
                 //
                 // A CSS AtRule
                 //
@@ -5179,6 +5236,7 @@
                     var hasUnknown;
                     var hasBlock = true;
                     var isRooted = true;
+                    var isKeywordList = false;
                     if (parserInput.currentChar() !== '@') {
                         return;
                     }
@@ -5216,6 +5274,9 @@
                         case '@starting-style':
                             isRooted = false;
                             break;
+                        case '@layer':
+                            isRooted = false;
+                            break;
                         default:
                             hasUnknown = true;
                             break;
@@ -5234,21 +5295,30 @@
                         }
                     }
                     else if (hasUnknown) {
-                        value = this.permissiveValue(/^[{;]/);
-                        hasBlock = (parserInput.currentChar() === '{');
-                        if (!value) {
-                            if (!hasBlock && parserInput.currentChar() !== ';') {
-                                error("".concat(name, " rule is missing block or ending semi-colon"));
-                            }
-                        }
-                        else if (!value.value) {
-                            value = null;
-                        }
+                        var unknownPackage = this.atruleUnknown(value, name, hasBlock);
+                        value = unknownPackage[0];
+                        hasBlock = unknownPackage[1];
                     }
                     if (hasBlock) {
-                        rules = this.blockRuleset();
+                        var 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);
+                            value = unknownPackage[0];
+                            hasBlock = unknownPackage[1];
+                            if (hasBlock) {
+                                blockPackage = this.atruleBlock(rules, value, isRooted, isKeywordList);
+                                rules = blockPackage[0];
+                                value = blockPackage[1];
+                                isKeywordList = blockPackage[2];
+                            }
+                        }
                     }
-                    if (rules || (!hasBlock && value && parserInput.$char(';'))) {
+                    if (rules || isKeywordList || (!hasBlock && value && parserInput.$char(';'))) {
                         parserInput.forget();
                         return new (tree.AtRule)(name, value, rules, index + currentIndex, fileInfo, context.dumpLineNumbers ? getDebugInfo(index) : null, isRooted);
                     }
@@ -5301,6 +5371,15 @@
                     }
                     parserInput.restore();
                 },
+                colorOperand: function () {
+                    parserInput.save();
+                    // hsl or rgb or lch operand
+                    var match = parserInput.$re(/^[lchrgbs]\s+/);
+                    if (match) {
+                        return new tree.Keyword(match[0]);
+                    }
+                    parserInput.restore();
+                },
                 multiplication: function () {
                     var m;
                     var a;
@@ -5562,7 +5641,7 @@
                         entities.color() || entities.variable() ||
                         entities.property() || entities.call() ||
                         entities.quoted(true) || entities.colorKeyword() ||
-                        entities.mixinLookup();
+                        this.colorOperand() || entities.mixinLookup();
                     if (negate) {
                         o.parensInOp = true;
                         o = new (tree.Negative)(o);
@@ -7016,6 +7095,7 @@
             this.value = visitor.visitArray(this.value);
         },
         eval: function (context) {
+            var noSpacing = this.noSpacing;
             var returnValue;
             var mathOn = context.isMathOn();
             var inParenthesis = this.parens;
@@ -7047,6 +7127,7 @@
                 && (!(returnValue instanceof Dimension))) {
                 returnValue = new Paren(returnValue);
             }
+            returnValue.noSpacing = returnValue.noSpacing || noSpacing;
             return returnValue;
         },
         genCSS: function (context, output) {
@@ -7079,7 +7160,26 @@
                 this.rules = visitor.visitArray(this.rules);
             }
         },
+        evalFunction: function () {
+            if (!this.features || !Array.isArray(this.features.value) || this.features.value.length < 1) {
+                return;
+            }
+            var exprValues = this.features.value;
+            var expr, paren;
+            for (var index = 0; index < exprValues.length; ++index) {
+                expr = exprValues[index];
+                if (expr.type === 'Keyword' && index + 1 < exprValues.length) {
+                    paren = exprValues[index + 1];
+                    if (paren.type === 'Paren' && paren.noSpacing) {
+                        exprValues[index] = new Expression([expr, paren]);
+                        exprValues.splice(index + 1, 1);
+                        exprValues[index].noSpacing = true;
+                    }
+                }
+            }
+        },
         evalTop: function (context) {
+            this.evalFunction();
             var result = this;
             // Render all dependent Media blocks.
             if (context.mediaBlocks.length > 1) {
@@ -7094,6 +7194,7 @@
             return result;
         },
         evalNested: function (context) {
+            this.evalFunction();
             var i;
             var value;
             var path = context.mediaPath.concat([this]);
@@ -7212,6 +7313,13 @@
             else {
                 return rules.filter(function (node) { return (node.type === 'Declaration' || node.type === 'Comment'); }).length === rules.length;
             }
+        }, keywordList: function (rules) {
+            if (!Array.isArray(rules)) {
+                return false;
+            }
+            else {
+                return rules.filter(function (node) { return (node.type === 'Keyword' || node.type === 'Comment'); }).length === rules.length;
+            }
         }, accept: function (visitor) {
             var value = this.value, rules = this.rules, declarations = this.declarations;
             if (rules) {
@@ -7254,6 +7362,9 @@
             context.mediaBlocks = [];
             if (value) {
                 value = value.eval(context);
+                if (value.value && this.keywordList(value.value)) {
+                    value = new Anonymous(value.value.map(function (keyword) { return keyword.value; }).join(', '), this.getIndex(), this.fileInfo());
+                }
             }
             if (rules) {
                 rules = this.evalRoot(context, rules);
@@ -8008,6 +8119,20 @@
                     return [];
                 }
             }
+            if (this.features) {
+                var featureValue = this.features.value;
+                if (Array.isArray(featureValue) && featureValue.length >= 1) {
+                    var expr = featureValue[0];
+                    if (expr.type === 'Expression' && Array.isArray(expr.value) && expr.value.length >= 2) {
+                        featureValue = expr.value;
+                        var isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
+                            && featureValue[1].type === 'Paren';
+                        if (isLayer) {
+                            this.css = false;
+                        }
+                    }
+                }
+            }
             if (this.options.inline) {
                 var contents = new Anonymous(this.root, 0, {
                     filename: this.importedFilename,
@@ -8015,19 +8140,58 @@
                 }, true, true);
                 return this.features ? new Media([contents], this.features.value) : [contents];
             }
-            else if (this.css) {
+            else if (this.css || this.layerCss) {
                 var newImport = new Import(this.evalPath(context), features, this.options, this._index);
+                if (this.layerCss) {
+                    newImport.css = this.layerCss;
+                    newImport.path._fileInfo = this._fileInfo;
+                }
                 if (!newImport.css && this.error) {
                     throw this.error;
                 }
                 return newImport;
             }
             else if (this.root) {
+                if (this.features) {
+                    var featureValue = this.features.value;
+                    if (Array.isArray(featureValue) && featureValue.length === 1) {
+                        var expr = featureValue[0];
+                        if (expr.type === 'Expression' && Array.isArray(expr.value) && expr.value.length >= 2) {
+                            featureValue = expr.value;
+                            var isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
+                                && featureValue[1].type === 'Paren';
+                            if (isLayer) {
+                                this.layerCss = true;
+                                featureValue[0] = new Expression(featureValue.slice(0, 2));
+                                featureValue.splice(1, 1);
+                                featureValue[0].noSpacing = true;
+                                return this;
+                            }
+                        }
+                    }
+                }
                 ruleset = new Ruleset(null, copyArray(this.root.rules));
                 ruleset.evalImports(context);
                 return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;
             }
             else {
+                if (this.features) {
+                    var featureValue = this.features.value;
+                    if (Array.isArray(featureValue) && featureValue.length >= 1) {
+                        featureValue = featureValue[0].value;
+                        if (Array.isArray(featureValue) && featureValue.length >= 2) {
+                            var isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
+                                && featureValue[1].type === 'Paren';
+                            if (isLayer) {
+                                this.css = true;
+                                featureValue[0] = new Expression(featureValue.slice(0, 2));
+                                featureValue.splice(1, 1);
+                                featureValue[0].noSpacing = true;
+                                return this;
+                            }
+                        }
+                    }
+                }
                 return [];
             }
         }
@@ -11025,7 +11189,7 @@
         return render;
     }
 
-    var version = "4.3.0";
+    var version = "4.4.1";
 
     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