less 4.6.7 → 4.7.0

package/lib/less/deprecation.js

@@ -17,10 +17,13 @@ const deprecations = {
         description: 'The ./ operator is deprecated.'
     },
     'variable-in-unknown-value': {
-        description: '@[ident] in custom property values is treated as literal text.'
+        description: '@variable in custom property values is treated as literal text.'
+    },
+    'variable-in-at-rule-prelude': {
+        description: 'A bare @variable in an at-rule prelude (e.g. @media @foo) is deprecated. Use @{variable} interpolation instead.'
     },
     'property-in-unknown-value': {
-        description: '$[ident] in custom property values is treated as literal text.'
+        description: '$property in custom property values is treated as literal text.'
     },
     'js-eval': {
         description: 'Inline JavaScript evaluation (backtick expressions) is deprecated and will be removed in Less 5.x.'

package/lib/less/parser/parser-input.js

@@ -204,12 +204,23 @@ export default () => {
     /**
      * Permissive parsing. Ignores everything except matching {} [] () and quotes
      * until matching token (outside of blocks)
+     *
+     * @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 => {
+    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;
@@ -249,6 +260,12 @@ export default () => {
                     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++;
@@ -284,6 +301,7 @@ export default () => {
                     case '(':
                         blockStack.push(')');
                         blockDepth++;
+                        parenDepth++;
                         break;
                     case '[':
                         blockStack.push(']');
@@ -295,6 +313,7 @@ export default () => {
                         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);
@@ -310,6 +329,7 @@ export default () => {
             }
         } while (loop);
 
+        if (Array.isArray(returnVal)) { returnVal.bareVarIndex = bareVarIndex; }
         return returnVal ? returnVal : null;
     }
 

package/lib/less/parser/parser.js

@@ -62,6 +62,10 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
 
     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
@@ -71,6 +75,11 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
     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.warn(
@@ -86,6 +95,17 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
         );
     }
 
+    /**
+     * 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');
+    }
+
     function expect(arg, msg) {
         // some older browsers return typeof 'function' for RegExp
         const result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
@@ -1636,7 +1656,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             if (parserInput.$char(';')) {
                                 value = new Anonymous('');
                             } else {
-                                value = this.permissiveValue(/[;}]/, true);
+                                value = this.permissiveValue(/[;}]/);
                             }
                         }
                         // Try to store values as anonymous
@@ -1695,8 +1715,12 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
              * 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;
@@ -1723,7 +1747,20 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         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);
                     }
@@ -1750,7 +1787,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 }
                 parserInput.save();
 
-                value = parserInput.$parseUntil(tok);
+                value = parserInput.$parseUntil(tok, deprecateVariables);
 
                 if (value) {
                     if (typeof value === 'string') {
@@ -1760,6 +1797,14 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         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++) {
@@ -1776,11 +1821,14 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             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;
@@ -1889,7 +1937,17 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                     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' ||
@@ -1900,7 +1958,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         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();
 
@@ -1980,7 +2038,17 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             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; }
@@ -2094,8 +2162,24 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     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() !== ';') {
@@ -2111,16 +2195,16 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 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);
@@ -2205,12 +2289,25 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 parserInput.commentStore.length = 0;
 
                 if (hasIdentifier) {
-                    value = this.entity();
+                    value = this.atRuleEntity();
                     if (!value) {
                         error(`expected ${name} identifier`);
                     }
                 } 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`);
                     }

package/lib/less/tree/nested-at-rule.js

@@ -145,16 +145,16 @@ const NestableAtRulePrototype = {
         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.

package/lib/less-node/environment.js

@@ -8,7 +8,7 @@ class SourceMapGeneratorFallback {
     toJSON(){
         return null;
     }
-};
+}
 
 export default {
     encodeBase64: function encodeBase64(str) {
@@ -19,9 +19,9 @@ export default {
     mimeLookup: function (filename) {
         try {
             const mimeModule = require('mime');
-            return mimeModule ? mimeModule.lookup(filename) : "application/octet-stream";
+            return mimeModule ? mimeModule.lookup(filename) : 'application/octet-stream';
         } catch (e) {
-            return "application/octet-stream";
+            return 'application/octet-stream';
         }
     },
     charsetLookup: function (mime) {

package/lib/less-node/image-size.js

@@ -1,3 +1,4 @@
+import { readFileSync } from 'fs';
 import { createRequire } from 'module';
 import Dimension from '../less/tree/dimension.js';
 import Expression from '../less/tree/expression.js';
@@ -33,27 +34,45 @@ export default environment => {
             throw fileSync.error;
         }
 
-        const sizeOf = require('image-size');
-        return sizeOf ? sizeOf(fileSync.filename) : {width: 0, height: 0};
+        let probe;
+        try {
+            probe = require('probe-image-size/sync');
+        } catch (_) {
+            return { width: 0, height: 0 };
+        }
+
+        const size = probe(readFileSync(fileSync.filename));
+
+        if (!size) {
+            throw {
+                type: 'File',
+                message: `Unrecognised image format for '${filePath}'`
+            };
+        }
+
+        return {
+            width: size.width,
+            height: size.height
+        };
     }
 
     const imageFunctions = {
-        'image-size': function(filePathNode) {
+        'image-size': function (filePathNode) {
             const size = imageSize(this, filePathNode);
             return new Expression([
                 new Dimension(size.width, 'px'),
                 new Dimension(size.height, 'px')
             ]);
         },
-        'image-width': function(filePathNode) {
+        'image-width': function (filePathNode) {
             const size = imageSize(this, filePathNode);
             return new Dimension(size.width, 'px');
         },
-        'image-height': function(filePathNode) {
+        'image-height': function (filePathNode) {
             const size = imageSize(this, filePathNode);
             return new Dimension(size.height, 'px');
         }
     };
 
     functionRegistry.addMultiple(imageFunctions);
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "less",
-	"version": "4.6.7",
+	"version": "4.7.0",
 	"description": "Leaner CSS",
 	"homepage": "http://lesscss.org",
 	"author": {
@@ -70,7 +70,7 @@
 	"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",