less 4.6.7 → 4.8.0

package/dist/less.cjs

@@ -1,5 +1,5 @@
 /**
- * Less - Leaner CSS v4.6.7
+ * Less - Leaner CSS v4.8.0
  * http://lesscss.org
  *
  * Copyright (c) 2009-2026, Alexis Sellier <self@cloudhead.net>
@@ -4100,12 +4100,23 @@
         /**
          * Permissive parsing. Ignores everything except matching {} [] () and quotes
          * until matching token (outside of blocks)
-         */
-        parserInput.$parseUntil = tok => {
+         *
+         * @param {string|RegExp} tok - stop token
+         * @param {boolean} [detectBareVar] - when set, also record the position of the
+         *   first bare `@variable` reference (not `@{interpolation}`) that appears at
+         *   PAREN depth 0 — i.e. a structural reference, not a declaration value inside
+         *   `(...)`. Reuses this single pass (which already skips strings/comments) so
+         *   callers don't re-scan the text. Exposed as `.bareVarIndex` on the returned
+         *   group array (or null). `[...]`/`{...}` do NOT shield a reference — only
+         *   `(...)` (a declaration-value group) does.
+         */
+        parserInput.$parseUntil = (tok, detectBareVar) => {
             let quote = '';
             let returnVal = null;
             let inComment = false;
             let blockDepth = 0;
+            let parenDepth = 0;
+            let bareVarIndex = null;
             const blockStack = [];
             const parseGroups = [];
             const length = input.length;
@@ -4145,6 +4156,12 @@
                         i++;
                         continue;
                     }
+                    if (detectBareVar && bareVarIndex === null && nextChar === '@' && parenDepth === 0) {
+                        // A bare `@ident` (not `@{interpolation}`) outside any `(...)` —
+                        // a structural reference. Strings/comments are already skipped above.
+                        const after = input.charAt(i + 1);
+                        if (after && /[-\w]/.test(after)) { bareVarIndex = i; }
+                    }
                     switch (nextChar) {
                         case '\\':
                             i++;
@@ -4180,6 +4197,7 @@
                         case '(':
                             blockStack.push(')');
                             blockDepth++;
+                            parenDepth++;
                             break;
                         case '[':
                             blockStack.push(']');
@@ -4191,6 +4209,7 @@
                             const expected = blockStack.pop();
                             if (nextChar === expected) {
                                 blockDepth--;
+                                if (nextChar === ')' && parenDepth > 0) { parenDepth--; }
                             } else {
                                 // move the parser to the error and return expected
                                 skipWhitespace(i - startPos);
@@ -4206,6 +4225,7 @@
                 }
             } while (loop);
 
+            if (Array.isArray(returnVal)) { returnVal.bareVarIndex = bareVarIndex; }
             return returnVal ? returnVal : null;
         };
 
@@ -4406,6 +4426,10 @@
 
         const deprecationHandler = new DeprecationHandler();
 
+        // Tracks `${deprecationId}@${index}` pairs already warned about, so a source
+        // position that gets re-parsed via parser backtracking only warns once.
+        const warnedDeprecations = new Set();
+
         /**
          * @param {string} msg
          * @param {number} index
@@ -4415,6 +4439,11 @@
         function warn(msg, index, type, deprecationId) {
             if (context.quiet) { return; }
             if (deprecationId && context.quietDeprecations) { return; }
+            if (deprecationId) {
+                const key = `${deprecationId}@${index ?? parserInput.i}`;
+                if (warnedDeprecations.has(key)) { return; }
+                warnedDeprecations.add(key);
+            }
             if (deprecationId && !deprecationHandler.shouldWarn(deprecationId)) { return; }
 
             logger$1.warn(
@@ -4430,6 +4459,75 @@
             );
         }
 
+        /**
+         * Warn that a bare `@variable` reference is being used in a non-value
+         * position (an at-rule prelude, name, or identifier), where it still
+         * resolves today but is deprecated in favour of `@{variable}` interpolation.
+         *
+         * @param {number} index - source position of the bare reference
+         */
+        function warnBareAtRuleVariable(index) {
+            warn('A bare @variable in an at-rule prelude is deprecated. Use @{variable} interpolation instead.', index, 'DEPRECATED', 'variable-in-at-rule-prelude');
+        }
+
+        /**
+         * Numeric-leading variable names are a Less extension rather than valid CSS
+         * identifier syntax. Keep accepting them through Less 4, but make the Less 5
+         * migration visible at every actual variable reference or definition.
+         *
+         * @param {string} name - either an @-prefixed name or the name inside @{...}
+         * @param {number} index - source position of the variable token
+         */
+        function warnNumericVariableName(name, index) {
+            if (/^(?:@@?)?[0-9]/.test(name)) {
+                warn('Variable names beginning with a number are deprecated and will be removed in Less 5.x. Rename the variable to start with a valid identifier character.', index, 'DEPRECATED', 'numeric-variable-name');
+            }
+        }
+
+        /**
+         * A lone '-' is not a CSS identifier. Less historically accepts it as a
+         * variable name; retain that in Less 4 only and warn on definitions,
+         * ordinary references, and interpolation references.
+         *
+         * @param {string} name - either @-/@@-, or the name inside @{...}
+         * @param {number} index - source position of the variable token
+         */
+        function warnDashOnlyVariableName(name, index) {
+            const bareName = name.replace(/^@@?/, '');
+            if (bareName === '-') {
+                warn('The dash-only variable names @- and @{-} are deprecated and will be removed in Less 5.x. Rename the variable to use a valid identifier.', index, 'DEPRECATED', 'dash-only-variable-name');
+            }
+        }
+
+        /**
+         * A lone '-' is not a CSS identifier. Less historically accepts it as a mixin
+         * name after '.' or '#'; retain that in Less 4 only.
+         *
+         * @param {string} name
+         * @param {number} index
+         */
+        function warnDashOnlyMixinName(name, index) {
+            if (name === '.-' || name === '#-') {
+                warn('The dash-only mixin names .-() and #-() are deprecated and will be removed in Less 5.x. Rename the mixin to use a valid CSS identifier.', index, 'DEPRECATED', 'dash-only-mixin-name');
+            }
+        }
+
+        /**
+         * CSS @charset is a source-header declaration, not a general dynamic at-rule.
+         * Less 4 keeps its historical interpolation behavior for compatibility, but
+         * makes each dynamic spelling visible before Less 5 rejects it.
+         *
+         * @param {import('../tree/node.js').default} value
+         * @param {number} index - source position of the @charset token
+         */
+        function warnDynamicCharset(value, index) {
+            if (value instanceof tree.Variable ||
+                (value instanceof tree.Quoted &&
+                    (value.containsVariables() || value.value.match(value.propRegex)))) {
+                warn('Dynamic @charset interpolation is deprecated and will be removed in Less 5.x. Use a static quoted encoding declaration instead.', index, 'DEPRECATED', 'dynamic-charset');
+            }
+        }
+
         function expect(arg, msg) {
             // some older browsers return typeof 'function' for RegExp
             const result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
@@ -4883,7 +4981,7 @@
                         }
 
                         function condition() {
-                            return [expect(parsers.condition, 'expected condition')];
+                            return [expect(() => parsers.condition(false, true), 'expected condition')];
                         }
                     },
 
@@ -5008,6 +5106,8 @@
 
                         parserInput.save();
                         if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^@@?[\w-]+/))) {
+                            warnNumericVariableName(name, index);
+                            warnDashOnlyVariableName(name, index);
                             ch = parserInput.currentChar();
                             if ((ch === '(' && !parserInput.prevChar().match(/^\s/))
                                 || (ch === '[' && !parserInput.prevChar().match(/^\s/))) {
@@ -5030,6 +5130,8 @@
                         const index = parserInput.i;
 
                         if (parserInput.currentChar() === '@' && (curly = parserInput.$re(/^@\{([\w-]+)\}/))) {
+                            warnNumericVariableName(curly[1], index);
+                            warnDashOnlyVariableName(curly[1], index);
                             return new(tree.Variable)(`@${curly[1]}`, index + currentIndex, fileInfo);
                         }
                     },
@@ -5152,7 +5254,11 @@
                 variable: function () {
                     let name;
 
-                    if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) { return name[1]; }
+                    if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) {
+                        warnNumericVariableName(name[1], parserInput.i - name[0].length);
+                        warnDashOnlyVariableName(name[1], parserInput.i - name[0].length);
+                        return name[1];
+                    }
                 },
 
                 //
@@ -5182,6 +5288,8 @@
                         }
 
                         if (!inValue) {
+                            warnNumericVariableName(name[1], i);
+                            warnDashOnlyVariableName(name[1], i);
                             name = name[1];
                         }
 
@@ -5338,6 +5446,9 @@
                             if (inValue || parsers.end()) {
                                 parserInput.forget();
                                 const mixin = new(tree.mixin.Call)(elements, args, index + currentIndex, fileInfo, !lookups && important);
+                                for (const element of elements) {
+                                    warnDashOnlyMixinName(element.value, element._index - currentIndex);
+                                }
                                 if (lookups) {
                                     return new tree.NamespaceValue(mixin, lookups);
                                 }
@@ -5534,6 +5645,7 @@
                         let ruleset;
                         let cond;
                         let variadic = false;
+                        const index = parserInput.i;
                         if ((parserInput.currentChar() !== '.' && parserInput.currentChar() !== '#') ||
                             parserInput.peek(/^[^{]*\}/)) {
                             return;
@@ -5569,6 +5681,7 @@
 
                             if (ruleset) {
                                 parserInput.forget();
+                                warnDashOnlyMixinName(name, index);
                                 return new(tree.mixin.Definition)(name, params, ruleset, cond, variadic);
                             } else {
                                 parserInput.restore();
@@ -5980,7 +6093,7 @@
                                 if (parserInput.$char(';')) {
                                     value = new Anonymous('');
                                 } else {
-                                    value = this.permissiveValue(/[;}]/, true);
+                                    value = this.permissiveValue(/[;}]/);
                                 }
                             }
                             // Try to store values as anonymous
@@ -6039,8 +6152,12 @@
                  * math is allowed.
                  * 
                  * @param {RexExp} untilTokens - Characters to stop parsing at
+                 * @param {boolean} [deprecateVariables] - when set, this is an at-rule
+                 *   prelude (non-value position); accept `@{var}` interpolation and warn
+                 *   on a bare `@var` reference (which resolves today but is deprecated).
                  */
-                permissiveValue: function (untilTokens) {
+                permissiveValue: function (untilTokens, deprecateVariables) {
+                    const entities = this.entities;
                     let i;
                     let e;
                     let done;
@@ -6067,7 +6184,20 @@
                             value.push(e);
                             continue;
                         }
-                        e = this.entity();
+                        if (deprecateVariables) {
+                            // In an at-rule prelude, `@{var}` interpolation is the supported
+                            // form; consume it here so its `{` is not mistaken for a block.
+                            e = entities.variableCurly();
+                            if (!e) {
+                                const varIndex = parserInput.i;
+                                e = this.entity();
+                                if (e && e.type === 'Variable') {
+                                    warnBareAtRuleVariable(varIndex);
+                                }
+                            }
+                        } else {
+                            e = this.entity();
+                        }
                         if (e) {
                             value.push(e);
                         }
@@ -6094,7 +6224,7 @@
                     }
                     parserInput.save();
 
-                    value = parserInput.$parseUntil(tok);
+                    value = parserInput.$parseUntil(tok, deprecateVariables);
 
                     if (value) {
                         if (typeof value === 'string') {
@@ -6104,6 +6234,14 @@
                             parserInput.forget();
                             return new tree.Anonymous('', index);
                         }
+                        // At-rule prelude: `$parseUntil` (deprecateVariables) records the
+                        // first bare `@var` it saw outside any `(...)` in its single pass —
+                        // a structural reference (`[...]`/`{...}` don't shield it, only a
+                        // declaration-value `(...)` does). Warn once here rather than
+                        // re-scanning the text.
+                        if (deprecateVariables && value.bareVarIndex !== null && value.bareVarIndex !== undefined) {
+                            warnBareAtRuleVariable(value.bareVarIndex);
+                        }
                         /** @type {string} */
                         let item;
                         for (i = 0; i < value.length; i++) {
@@ -6120,11 +6258,14 @@
                                 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', 'variable-in-unknown-value');
+                                // At-rule preludes are handled once above via
+                                // `value.bareVarIndex`; the `variable-in-unknown-value`
+                                // notice is for unknown declaration values only.
+                                if (!deprecateVariables && variableRegex.test(item)) {
+                                    warn('@variable in unknown values will not be evaluated as variables in the future. Use @{variable}', 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', 'property-in-unknown-value');
+                                    warn('$property in unknown values will not be evaluated as property references in the future. Use ${property}', index, 'DEPRECATED', 'property-in-unknown-value');
                                 }
                                 quote.variableRegex = /@([\w-]+)|@{([\w-]+)}/g;
                                 quote.propRegex = /\$([\w-]+)|\${([\w-]+)}/g;
@@ -6233,7 +6374,17 @@
                         }
                         parserInput.restore();
 
-                        e = entities.declarationCall.bind(this)() || cssKeyword() || entities.keyword() || entities.variable() || entities.mixinLookup();
+                        e = entities.declarationCall.bind(this)() || cssKeyword() || entities.keyword() || entities.variableCurly();
+                        if (!e) {
+                            const varIndex = parserInput.i;
+                            const bareVariable = entities.variable();
+                            if (bareVariable) {
+                                warnBareAtRuleVariable(varIndex);
+                                e = bareVariable;
+                            } else {
+                                e = entities.mixinLookup();
+                            }
+                        }
                         if (e) {
                             nodes.push(e);
                             if (e.type === 'Variable' ||
@@ -6244,7 +6395,7 @@
                             let closed = false;
                             p = this.property();
                             parserInput.save();
-                            if (!p && syntaxOptions.queryInParens && parserInput.$re(/^[0-9a-z-]*\s*([<>]=|<=|>=|[<>]|=)/)) {
+                            if (!p && syntaxOptions.queryInParens && parserInput.$re(/^(?:[^()]|\([^()]*\))*\s*([<>]=|<=|>=|[<>]|=)/)) {
                                 parserInput.restore();
                                 p = this.condition();
 
@@ -6324,7 +6475,17 @@
                                 features[features.length - 1].noSpacing = false;
                             }
                         } else {
-                            e = entities.variable() || entities.mixinLookup();
+                            e = entities.variableCurly();
+                            if (!e) {
+                                const varIndex = parserInput.i;
+                                const bareVariable = entities.variable();
+                                if (bareVariable) {
+                                    warnBareAtRuleVariable(varIndex);
+                                    e = bareVariable;
+                                } else {
+                                    e = entities.mixinLookup();
+                                }
+                            }
                             if (e) {
                                 features.push(e);
                                 if (!parserInput.$char(',')) { break; }
@@ -6438,8 +6599,24 @@
                         return null;
                     }
                 },
+                /**
+                 * An entity in a non-value at-rule position (an at-rule identifier,
+                 * name, or keyword-list item — e.g. the name in `@keyframes @foo`).
+                 * `@{foo}` interpolation is the supported form; a bare `@foo` still
+                 * resolves but is deprecated.
+                 */
+                atRuleEntity: function () {
+                    const curly = this.entities.variableCurly();
+                    if (curly) { return curly; }
+                    const index = parserInput.i;
+                    const e = this.entity();
+                    if (e && e.type === 'Variable') {
+                        warnBareAtRuleVariable(index);
+                    }
+                    return e;
+                },
                 atruleUnknown: function (value, name, hasBlock) {
-                    value = this.permissiveValue(/^[{;]/);
+                    value = this.permissiveValue(/^[{;]/, true);
                     hasBlock = (parserInput.currentChar() === '{');
                     if (!value) {
                         if (!hasBlock && parserInput.currentChar() !== ';') {
@@ -6455,16 +6632,16 @@
                     rules = this.blockRuleset();
                     parserInput.save();
                     if (!rules && !isRooted) {
-                        value = this.entity();
+                        value = this.atRuleEntity();
                         rules = this.blockRuleset();
                     }
                     if (!rules && !isRooted) {
                         parserInput.restore();
                         var e = [];
-                        value = this.entity();
+                        value = this.atRuleEntity();
                         while (parserInput.$char(',')) {
                             e.push(value);
-                            value = this.entity();
+                            value = this.atRuleEntity();
                         }
                         if (value && e.length > 0) {
                             e.push(value);
@@ -6549,12 +6726,28 @@
                     parserInput.commentStore.length = 0;
 
                     if (hasIdentifier) {
-                        value = this.entity();
+                        value = this.atRuleEntity();
                         if (!value) {
                             error(`expected ${name} identifier`);
                         }
+                        if (nonVendorSpecificName === '@charset') {
+                            warnDynamicCharset(value, index);
+                        }
                     } else if (hasExpression) {
+                        // `@namespace` may carry an interpolated `@{ns}` prefix (or a
+                        // deprecated bare `@ns`). Parse that prefix directly so `@{ns}`
+                        // is accepted here without treating value positions as
+                        // interpolation contexts, then read the namespace URL.
+                        let prefix = this.entities.variableCurly();
+                        if (!prefix && parserInput.peek(/^@@?[\w-]/)) {
+                            const prefixIndex = parserInput.i;
+                            prefix = this.entities.variable();
+                            if (prefix) { warnBareAtRuleVariable(prefixIndex); }
+                        }
                         value = this.expression();
+                        if (prefix) {
+                            value = value ? new(tree.Expression)([prefix, ...value.value]) : prefix;
+                        }
                         if (!value) {
                             error(`expected ${name} expression`);
                         }
@@ -6744,7 +6937,7 @@
                         return condition || a;
                     }
                 },
-                condition: function (needsParens) {
+                condition: function (needsParens, allowConditionOperands) {
                     let result;
                     let logical;
                     let next;
@@ -6752,13 +6945,13 @@
                         return parserInput.$str('or');
                     }
 
-                    result = this.conditionAnd(needsParens);
+                    result = this.conditionAnd(needsParens, allowConditionOperands);
                     if (!result) {
                         return ;
                     }
                     logical = or();
                     if (logical) {
-                        next = this.condition(needsParens);
+                        next = this.condition(needsParens, allowConditionOperands);
                         if (next) {
                             result = new(tree.Condition)(logical, result, next);
                         } else {
@@ -6767,13 +6960,13 @@
                     }
                     return result;
                 },
-                conditionAnd: function (needsParens) {
+                conditionAnd: function (needsParens, allowConditionOperands) {
                     let result;
                     let logical;
                     let next;
                     const self = this;
                     function insideCondition() {
-                        const cond = self.negatedCondition(needsParens) || self.parenthesisCondition(needsParens);
+                        const cond = self.negatedCondition(needsParens, allowConditionOperands) || self.parenthesisCondition(needsParens, allowConditionOperands);
                         if (!cond && !needsParens) {
                             return self.atomicCondition(needsParens);
                         }
@@ -6787,9 +6980,12 @@
                     if (!result) {
                         return ;
                     }
+                    if (allowConditionOperands) {
+                        result = this.atomicCondition(needsParens, result, allowConditionOperands) || result;
+                    }
                     logical = and();
                     if (logical) {
-                        next = this.conditionAnd(needsParens);
+                        next = this.conditionAnd(needsParens, allowConditionOperands);
                         if (next) {
                             result = new(tree.Condition)(logical, result, next);
                         } else {
@@ -6798,9 +6994,9 @@
                     }
                     return result;
                 },
-                negatedCondition: function (needsParens) {
+                negatedCondition: function (needsParens, allowConditionOperands) {
                     if (parserInput.$str('not')) {
-                        const result = this.parenthesisCondition(needsParens);
+                        const result = this.parenthesisCondition(needsParens, allowConditionOperands);
                         if (result) {
                             result.negate = !result.negate;
                             return result;
@@ -6817,11 +7013,11 @@
                         }
                     }
                 },
-                parenthesisCondition: function (needsParens) {
+                parenthesisCondition: function (needsParens, allowConditionOperands) {
                     function tryConditionFollowedByParenthesis(me) {
                         let body;
                         parserInput.save();
-                        body = me.condition(needsParens);
+                        body = me.condition(needsParens, allowConditionOperands);
                         if (!body) {
                             parserInput.restore();
                             return ;
@@ -6858,7 +7054,7 @@
                     parserInput.forget();
                     return body;
                 },
-                atomicCondition: function (needsParens, preparsedCond) {
+                atomicCondition: function (needsParens, preparsedCond, allowConditionOperands) {
                     const entities = this.entities;
                     const index = parserInput.i;
                     let a;
@@ -6867,7 +7063,7 @@
                     let op;
 
                     const cond = (function() {
-                        return this.addition() || entities.keyword() || entities.quoted() || entities.mixinLookup();
+                        return (allowConditionOperands && this.parenthesisCondition(needsParens)) || this.addition() || entities.keyword() || entities.quoted() || entities.mixinLookup();
                     }).bind(this);
 
                     if (preparsedCond) {
@@ -7028,6 +7224,11 @@
                         }
                         for (k = 0; k < name.length; k++) {
                             s = name[k];
+                            if (s.charAt(0) === '@') {
+                                const variableName = s.slice(2, -1);
+                                warnNumericVariableName(variableName, index[k]);
+                                warnDashOnlyVariableName(variableName, index[k]);
+                            }
                             name[k] = (s.charAt(0) !== '@' && s.charAt(0) !== '$') ?
                                 new(tree.Keyword)(s) :
                                 (s.charAt(0) === '@' ?
@@ -8617,16 +8818,16 @@
             self.features = new Value(self.permute(/** @type {Node[][]} */ (/** @type {unknown} */ (path))).map(
                 /** @param {Node | Node[]} path */
                 path => {
-                path = /** @type {Node[]} */ (path).map(
+                    path = /** @type {Node[]} */ (path).map(
                     /** @param {Node & { toCSS?: Function }} fragment */
-                    fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
+                        fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
 
-                for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
+                    for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
                     /** @type {Node[]} */ (path).splice(i, 0, new Anonymous('and'));
-                }
+                    }
 
-                return new Expression(/** @type {Node[]} */ (path));
-            }));
+                    return new Expression(/** @type {Node[]} */ (path));
+                }));
             self.setParent(self.features, self);
 
             // Fake a tree-node that doesn't output anything.
@@ -10980,35 +11181,47 @@
          */
         matchArgs(args, context) {
             const allArgsCnt = (args && args.length) || 0;
-            let len;
-            const optionalParameters = this.optionalParameters;
-            const requiredArgsCnt = !args ? 0 : args.reduce(function (/** @type {number} */ count, /** @type {MixinArg} */ p) {
-                if (optionalParameters.indexOf(p.name) < 0) {
-                    return count + 1;
-                } else {
-                    return count;
+            const evaldArguments = new Array(this.params.length);
+            const positionalArgs = [];
+            let positionalIndex = 0;
+
+            for (let i = 0; i < allArgsCnt; i++) {
+                const arg = /** @type {MixinArg[]} */ (args)[i];
+                if (!arg.name) {
+                    positionalArgs.push(arg);
+                    continue;
                 }
-            }, 0);
 
-            if (!this.variadic) {
-                if (requiredArgsCnt < this.required) {
+                const paramIndex = this.params.findIndex((param, index) => param.name === arg.name && !evaldArguments[index]);
+                if (paramIndex < 0) {
                     return false;
                 }
-                if (allArgsCnt > this.params.length) {
-                    return false;
+                evaldArguments[paramIndex] = arg;
+            }
+
+            for (let i = 0; i < this.params.length; i++) {
+                if (evaldArguments[i]) {
+                    continue;
                 }
-            } else {
-                if (requiredArgsCnt < (this.required - 1)) {
+                if (this.params[i].variadic) {
+                    positionalIndex = positionalArgs.length;
+                    continue;
+                }
+                if (positionalIndex < positionalArgs.length) {
+                    evaldArguments[i] = positionalArgs[positionalIndex++];
+                } else if (!this.params[i].name || !this.params[i].value) {
                     return false;
                 }
             }
 
-            // check patterns
-            len = Math.min(requiredArgsCnt, this.arity);
+            if (positionalIndex < positionalArgs.length) {
+                return false;
+            }
 
-            for (let i = 0; i < len; i++) {
+            // check patterns
+            for (let i = 0; i < this.arity; i++) {
                 if (!this.params[i].name && !this.params[i].variadic) {
-                    if (/** @type {MixinArg[]} */ (args)[i].value.eval(context).toCSS(/** @type {EvalContext} */ ({})) != /** @type {Node} */ (this.params[i].value).eval(context).toCSS(/** @type {EvalContext} */ ({}))) {
+                    if (evaldArguments[i].value.eval(context).toCSS(/** @type {EvalContext} */ ({})) != /** @type {Node} */ (this.params[i].value).eval(context).toCSS(/** @type {EvalContext} */ ({}))) {
                         return false;
                     }
                 }
@@ -14175,7 +14388,7 @@
     };
 
     var name = "less";
-    var version = "4.6.7";
+    var version = "4.8.0";
     var description = "Leaner CSS";
     var homepage = "http://lesscss.org";
     var author = {
@@ -14245,7 +14458,7 @@
     var optionalDependencies = {
     	errno: "^0.1.1",
     	"graceful-fs": "^4.1.2",
-    	"image-size": "~0.5.0",
+    	"probe-image-size": "^7.2.3",
     	"make-dir": "^5.1.0",
     	mime: "^1.4.1",
     	needle: "^3.1.0",