vscode-css-languageservice 6.3.9 → 6.3.10

package/lib/umd/languageFacts/builtinData.js

@@ -60,7 +60,8 @@
     };
     exports.cssWideFunctions = {
         'var()': 'Evaluates the value of a custom variable.',
-        'calc()': 'Evaluates an mathematical expression. The following operators can be used: + - * /.'
+        'calc()': 'Evaluates an mathematical expression. The following operators can be used: + - * /.',
+        'if()': 'Evaluates a conditional expression.'
     };
     exports.imageFunctions = {
         'url()': 'Reference an image file by URL',

package/lib/umd/parser/cssErrors.js

@@ -56,5 +56,6 @@
         IdentifierOrWildcardExpected: new CSSIssueType('css-idorwildcardexpected', l10n.t("identifier or wildcard expected")),
         WildcardExpected: new CSSIssueType('css-wildcardexpected', l10n.t("wildcard expected")),
         IdentifierOrVariableExpected: new CSSIssueType('css-idorvarexpected', l10n.t("identifier or variable expected")),
+        IfConditionExpected: new CSSIssueType('css-ifconditionexpected', l10n.t("if condition expected")),
     };
 });

package/lib/umd/parser/cssParser.js

@@ -418,8 +418,8 @@
             }
             return hasContent ? this.finish(node) : null;
         }
-        _parseDeclaration(stopTokens) {
-            const customProperty = this._tryParseCustomPropertyDeclaration(stopTokens);
+        _parseDeclaration(stopTokens, standaloneCustomPropertyValid = false) {
+            const customProperty = this._tryParseCustomPropertyDeclaration(stopTokens, standaloneCustomPropertyValid);
             if (customProperty) {
                 return customProperty;
             }
@@ -442,7 +442,7 @@
             }
             return this.finish(node);
         }
-        _tryParseCustomPropertyDeclaration(stopTokens) {
+        _tryParseCustomPropertyDeclaration(stopTokens, standaloneCustomPropertyValid = false) {
             if (!this.peekRegExp(cssScanner_1.TokenType.Ident, /^--/)) {
                 return null;
             }
@@ -451,6 +451,9 @@
                 return null;
             }
             if (!this.accept(cssScanner_1.TokenType.Colon)) {
+                if (standaloneCustomPropertyValid) {
+                    return this.finish(node);
+                }
                 return this.finish(node, cssErrors_1.ParseError.ColonExpected, [cssScanner_1.TokenType.Colon]);
             }
             if (this.prevToken) {
@@ -1017,6 +1020,56 @@
             }
             return this.finish(node);
         }
+        _parseBooleanExpression(parseTest) {
+            // <boolean-expr[ <test> ]> = not <boolean-expr-group> | <boolean-expr-group>
+            //                                     [ [ and <boolean-expr-group> ]*
+            //                                     | [ or <boolean-expr-group> ]* ]
+            const node = this.create(nodes.Node);
+            if (this.acceptIdent('not')) {
+                if (!node.addChild(this._parseBooleanExpressionGroup(parseTest))) {
+                    return null;
+                }
+            }
+            else {
+                if (!node.addChild(this._parseBooleanExpressionGroup(parseTest))) {
+                    return null;
+                }
+                if (this.peekIdent('and')) {
+                    while (this.acceptIdent('and')) {
+                        if (!node.addChild(this._parseBooleanExpressionGroup(parseTest))) {
+                            return null;
+                        }
+                    }
+                }
+                else if (this.peekIdent('or')) {
+                    while (this.acceptIdent('or')) {
+                        if (!node.addChild(this._parseBooleanExpressionGroup(parseTest))) {
+                            return null;
+                        }
+                    }
+                }
+            }
+            return this.finish(node);
+        }
+        _parseBooleanExpressionGroup(parseTest) {
+            // <boolean-expr-group> = <test> | ( <boolean-expr[ <test> ]> ) | <general-enclosed>
+            const node = this.create(nodes.Node);
+            const pos = this.mark();
+            if (this.accept(cssScanner_1.TokenType.ParenthesisL)) {
+                if (node.addChild(this._parseBooleanExpression(parseTest))) {
+                    if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
+                        return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected, [], [cssScanner_1.TokenType.CurlyL]);
+                    }
+                    return this.finish(node);
+                }
+                this.restoreAtMark(pos);
+            }
+            if (!node.addChild(parseTest())) {
+                return null;
+            }
+            ;
+            return this.finish(node);
+        }
         _parseMediaCondition() {
             // <media-condition> = <media-not> | <media-and> | <media-or> | <media-in-parens>
             // <media-not> = not <media-in-parens>
@@ -1136,7 +1189,7 @@
             if (this.accept(cssScanner_1.TokenType.ParenthesisL)) {
                 // scope-start selector can start with a combinator as it defaults to :scope
                 // Treat as nested
-                if (!node.setScopeStart(this._parseSelector(true))) {
+                if (!node.setScopeStart(this._parseScopeSelectorList())) {
                     return this.finish(node, cssErrors_1.ParseError.SelectorExpected, [], [cssScanner_1.TokenType.ParenthesisR]);
                 }
                 if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
@@ -1150,7 +1203,7 @@
                 }
                 // 'to' selector can start with a combinator as it defaults to :scope
                 // Treat as nested
-                if (!node.setScopeEnd(this._parseSelector(true))) {
+                if (!node.setScopeEnd(this._parseScopeSelectorList())) {
                     return this.finish(node, cssErrors_1.ParseError.SelectorExpected, [], [cssScanner_1.TokenType.ParenthesisR]);
                 }
                 if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
@@ -1159,6 +1212,16 @@
             }
             return this.finish(node);
         }
+        _parseScopeSelectorList() {
+            const selectors = this.createNode(nodes.NodeType.SelectorList);
+            if (!selectors.addChild(this._parseSelector(true))) {
+                return null;
+            }
+            while (this.accept(cssScanner_1.TokenType.Comma) && selectors.addChild(this._parseSelector(true))) {
+                // loop
+            }
+            return this.finish(selectors);
+        }
         _parseMedium() {
             const node = this.create(nodes.Node);
             if (node.addChild(this._parseIdent())) {
@@ -1239,7 +1302,15 @@
             const node = this.create(nodes.Container);
             this.consumeToken(); // @container
             node.addChild(this._parseIdent()); // optional container name
-            node.addChild(this._parseContainerQuery());
+            if (node.addChild(this._parseContainerQuery())) {
+                while (this.accept(cssScanner_1.TokenType.Comma)) {
+                    if (this.peek(cssScanner_1.TokenType.CurlyL)) {
+                        break;
+                    }
+                    node.addChild(this._parseIdent()); // optional container name
+                    node.addChild(this._parseContainerQuery());
+                }
+            }
             return this._parseBody(node, this._parseContainerDeclaration.bind(this, isNested));
         }
         _parseContainerQuery() {
@@ -1250,7 +1321,7 @@
                 node.addChild(this._parseContainerQueryInParens());
             }
             else {
-                node.addChild(this._parseContainerQueryInParens());
+                node.addChild(this._parseContainerQueryInParens(true));
                 if (this.peekIdent('and')) {
                     while (this.acceptIdent('and')) {
                         node.addChild(this._parseContainerQueryInParens());
@@ -1264,7 +1335,7 @@
             }
             return this.finish(node);
         }
-        _parseContainerQueryInParens() {
+        _parseContainerQueryInParens(optional = false) {
             // <query-in-parens>     = ( <container-query> )
             // 					  | ( <size-feature> )
             // 					  | style( <style-query> )
@@ -1291,6 +1362,9 @@
                 }
             }
             else {
+                if (optional) {
+                    return null;
+                }
                 return this.finish(node, cssErrors_1.ParseError.LeftParenthesisExpected, [], [cssScanner_1.TokenType.CurlyL]);
             }
             return this.finish(node);
@@ -1320,7 +1394,7 @@
                 }
             }
             else {
-                node.addChild(this._parseDeclaration([cssScanner_1.TokenType.ParenthesisR]));
+                node.addChild(this._parseDeclaration([cssScanner_1.TokenType.ParenthesisR], true));
             }
             return this.finish(node);
         }
@@ -1826,6 +1900,12 @@
         _parseFunction() {
             const pos = this.mark();
             const node = this.create(nodes.Function);
+            let parseArgument = this._parseFunctionArgument.bind(this);
+            let separator = cssScanner_1.TokenType.Comma;
+            if (this.peekIdent("if")) {
+                parseArgument = this._parseIfBranch.bind(this);
+                separator = cssScanner_1.TokenType.SemiColon;
+            }
             if (!node.setIdentifier(this._parseFunctionIdentifier())) {
                 return null;
             }
@@ -1833,12 +1913,12 @@
                 this.restoreAtMark(pos);
                 return null;
             }
-            if (node.getArguments().addChild(this._parseFunctionArgument())) {
-                while (this.accept(cssScanner_1.TokenType.Comma)) {
+            if (node.getArguments().addChild(parseArgument())) {
+                while (this.accept(separator)) {
                     if (this.peek(cssScanner_1.TokenType.ParenthesisR)) {
                         break;
                     }
-                    if (!node.getArguments().addChild(this._parseFunctionArgument())) {
+                    if (!node.getArguments().addChild(parseArgument())) {
                         this.markError(node, cssErrors_1.ParseError.ExpressionExpected);
                     }
                 }
@@ -1873,6 +1953,73 @@
             }
             return null;
         }
+        _parseIfBranch() {
+            // <if-branch> = <if-condition> : <declaration-value>?
+            const node = this.create(nodes.Node);
+            if (!node.addChild(this._parseIfCondition())) {
+                return this.finish(node, cssErrors_1.ParseError.IfConditionExpected, [], [cssScanner_1.TokenType.SemiColon]);
+            }
+            if (!this.accept(cssScanner_1.TokenType.Colon)) {
+                return this.finish(node, cssErrors_1.ParseError.ColonExpected, [], [cssScanner_1.TokenType.SemiColon]);
+            }
+            node.addChild(this._parseExpr());
+            return this.finish(node);
+        }
+        _parseIfCondition() {
+            // <if-condition> = <boolean-expr[ <if-test> ]> | else
+            const node = this.create(nodes.Node);
+            if (this.peekIdent("else")) {
+                node.addChild(this._parseIdent());
+                return this.finish(node);
+            }
+            return this._parseBooleanExpression(this._parseIfTest.bind(this));
+        }
+        _parseIfTest() {
+            // <if-test> =
+            // 	supports( [ <ident> : <declaration-value> ] | <supports-condition> ) |
+            // 	media( <media-feature> | <media-condition> ) |
+            // 	style( <style-query> )
+            const node = this.create(nodes.Node);
+            if (this.acceptIdent('supports')) {
+                if (this.hasWhitespace() || !this.accept(cssScanner_1.TokenType.ParenthesisL)) {
+                    return this.finish(node, cssErrors_1.ParseError.LeftParenthesisExpected, [], [cssScanner_1.TokenType.Colon]);
+                }
+                node.addChild(this._tryToParseDeclaration() || this._parseSupportsCondition());
+                if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
+                    return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected, [], [cssScanner_1.TokenType.Colon]);
+                }
+                return this.finish(node);
+            }
+            if (this.acceptIdent('media')) {
+                if (this.hasWhitespace() || !this.accept(cssScanner_1.TokenType.ParenthesisL)) {
+                    return this.finish(node, cssErrors_1.ParseError.LeftParenthesisExpected, [], [cssScanner_1.TokenType.Colon]);
+                }
+                const pos = this.mark();
+                const condition = this._parseMediaCondition();
+                if (condition && !condition.isErroneous()) {
+                    node.addChild(condition);
+                }
+                else {
+                    this.restoreAtMark(pos);
+                    node.addChild(this._parseMediaFeature());
+                }
+                if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
+                    return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected, [], [cssScanner_1.TokenType.Colon]);
+                }
+                return this.finish(node);
+            }
+            if (this.acceptIdent('style')) {
+                if (this.hasWhitespace() || !this.accept(cssScanner_1.TokenType.ParenthesisL)) {
+                    return this.finish(node, cssErrors_1.ParseError.LeftParenthesisExpected, [], [cssScanner_1.TokenType.Colon]);
+                }
+                node.addChild(this._parseStyleQuery());
+                if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
+                    return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected, [], [cssScanner_1.TokenType.Colon]);
+                }
+                return this.finish(node);
+            }
+            return null;
+        }
         _parseHexColor() {
             if (this.peekRegExp(cssScanner_1.TokenType.Hash, /^#([A-Fa-f0-9]{3}|[A-Fa-f0-9]{4}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/g)) {
                 const node = this.create(nodes.HexColorValue);

package/lib/umd/parser/scssParser.js

@@ -627,6 +627,64 @@
         _parseMixinReferenceBodyStatement() {
             return this._tryParseKeyframeSelector() || this._parseRuleSetDeclaration();
         }
+        _parseIfTest() {
+            const node = this.create(nodes.Node);
+            if (this.acceptIdent('sass')) {
+                if (this.hasWhitespace() || !this.accept(cssScanner_1.TokenType.ParenthesisL)) {
+                    return this.finish(node, cssErrors_1.ParseError.LeftParenthesisExpected, [], [cssScanner_1.TokenType.CurlyL]);
+                }
+                node.addChild(this._parseExpr());
+                if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
+                    return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected, [], [cssScanner_1.TokenType.CurlyL]);
+                }
+                return this.finish(node);
+            }
+            return super._parseIfTest();
+        }
+        _parseFunction() {
+            const pos = this.mark();
+            const node = this.create(nodes.Function);
+            let isIf = this.peekIdent('if');
+            if (!node.setIdentifier(this._parseFunctionIdentifier())) {
+                return null;
+            }
+            if (this.hasWhitespace() || !this.accept(cssScanner_1.TokenType.ParenthesisL)) {
+                this.restoreAtMark(pos);
+                return null;
+            }
+            let firstArgument;
+            let parseArgument = this._parseFunctionArgument.bind(this);
+            let separator = cssScanner_1.TokenType.Comma;
+            if (!isIf) {
+                firstArgument = this._parseFunctionArgument();
+            }
+            else {
+                const pos = this.mark();
+                firstArgument = this._parseIfBranch();
+                if (firstArgument && !firstArgument.isErroneous()) {
+                    parseArgument = this._parseIfBranch.bind(this);
+                    separator = cssScanner_1.TokenType.SemiColon;
+                }
+                else {
+                    this.restoreAtMark(pos);
+                    firstArgument = this._parseFunctionArgument();
+                }
+            }
+            if (node.getArguments().addChild(firstArgument)) {
+                while (this.accept(separator)) {
+                    if (this.peek(cssScanner_1.TokenType.ParenthesisR)) {
+                        break;
+                    }
+                    if (!node.getArguments().addChild(parseArgument())) {
+                        this.markError(node, cssErrors_1.ParseError.ExpressionExpected);
+                    }
+                }
+            }
+            if (!this.accept(cssScanner_1.TokenType.ParenthesisR)) {
+                return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected);
+            }
+            return this.finish(node);
+        }
         _parseFunctionArgument() {
             // [variableName ':'] expression | variableName '...'
             const node = this.create(nodes.FunctionArgument);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vscode-css-languageservice",
-  "version": "6.3.9",
+  "version": "6.3.10",
   "description": "Language service for CSS, LESS and SCSS",
   "main": "./lib/umd/cssLanguageService.js",
   "typings": "./lib/umd/cssLanguageService",
@@ -17,13 +17,13 @@
   "devDependencies": {
     "@types/mocha": "^10.0.10",
     "@types/node": "22.x",
-    "@typescript-eslint/eslint-plugin": "^8.48.0",
-    "@typescript-eslint/parser": "^8.48.0",
-    "@vscode/web-custom-data": "^0.6.2",
-    "eslint": "^9.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "@vscode/web-custom-data": "^0.6.3",
+    "eslint": "^9.39.3",
     "js-beautify": "^1.15.4",
     "mocha": "^11.7.5",
-    "rimraf": "^6.1.2",
+    "rimraf": "^6.1.3",
     "source-map-support": "^0.5.21",
     "typescript": "^5.9.3"
   },