vscode-css-languageservice 6.3.9 → 7.0.0-next.1

package/lib/esm/languageFacts/builtinData.js

@@ -49,7 +49,8 @@ export const cssWideKeywords = {
 };
 export const 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.'
 };
 export const imageFunctions = {
     'url()': 'Reference an image file by URL',

package/lib/esm/languageFacts/colors.js

@@ -2,7 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as nodes from '../parser/cssNodes';
+import * as nodes from '../parser/cssNodes.js';
 import * as l10n from '@vscode/l10n';
 const hexColorRegExp = /(^#([0-9A-F]{3}){1,2}$)|(^#([0-9A-F]{4}){1,2}$)/i;
 export const colorFunctions = [

package/lib/esm/languageFacts/dataManager.js

@@ -3,9 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as objects from '../utils/objects';
-import { cssData } from '../data/webCustomData';
-import { CSSDataProvider } from './dataProvider';
+import * as objects from '../utils/objects.js';
+import { cssData } from '../data/webCustomData.js';
+import { CSSDataProvider } from './dataProvider.js';
 export class CSSDataManager {
     constructor(options) {
         this.dataProviders = [];

package/lib/esm/languageFacts/entry.js

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { MarkupKind } from '../cssLanguageTypes';
+import { MarkupKind } from '../cssLanguageTypes.js';
 export const browserNames = {
     'C': {
         name: 'Chrome',

package/lib/esm/languageFacts/facts.js

@@ -3,6 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-export * from './entry';
-export * from './colors';
-export * from './builtinData';
+export * from './entry.js';
+export * from './colors.js';
+export * from './builtinData.js';

package/lib/esm/parser/cssErrors.js

@@ -44,4 +44,5 @@ export const ParseError = {
     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/esm/parser/cssNodes.js

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { trim } from "../utils/strings";
+import { trim } from "../utils/strings.js";
 /// <summary>
 /// Nodes for the css 2.1 specification. See for reference:
 /// http://www.w3.org/TR/CSS21/grammar.html#grammar

package/lib/esm/parser/cssParser.js

@@ -3,11 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { TokenType, Scanner } from './cssScanner';
-import * as nodes from './cssNodes';
-import { ParseError } from './cssErrors';
-import * as languageFacts from '../languageFacts/facts';
-import { isDefined } from '../utils/objects';
+import { TokenType, Scanner } from './cssScanner.js';
+import * as nodes from './cssNodes.js';
+import { ParseError } from './cssErrors.js';
+import * as languageFacts from '../languageFacts/facts.js';
+import { isDefined } from '../utils/objects.js';
 /// <summary>
 /// A parser for the css core specification. See for reference:
 /// https://www.w3.org/TR/CSS21/grammar.html
@@ -407,8 +407,8 @@ export class Parser {
         }
         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;
         }
@@ -431,7 +431,7 @@ export class Parser {
         }
         return this.finish(node);
     }
-    _tryParseCustomPropertyDeclaration(stopTokens) {
+    _tryParseCustomPropertyDeclaration(stopTokens, standaloneCustomPropertyValid = false) {
         if (!this.peekRegExp(TokenType.Ident, /^--/)) {
             return null;
         }
@@ -440,6 +440,9 @@ export class Parser {
             return null;
         }
         if (!this.accept(TokenType.Colon)) {
+            if (standaloneCustomPropertyValid) {
+                return this.finish(node);
+            }
             return this.finish(node, ParseError.ColonExpected, [TokenType.Colon]);
         }
         if (this.prevToken) {
@@ -1006,6 +1009,56 @@ export class Parser {
         }
         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(TokenType.ParenthesisL)) {
+            if (node.addChild(this._parseBooleanExpression(parseTest))) {
+                if (!this.accept(TokenType.ParenthesisR)) {
+                    return this.finish(node, ParseError.RightParenthesisExpected, [], [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>
@@ -1125,7 +1178,7 @@ export class Parser {
         if (this.accept(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, ParseError.SelectorExpected, [], [TokenType.ParenthesisR]);
             }
             if (!this.accept(TokenType.ParenthesisR)) {
@@ -1139,7 +1192,7 @@ export class Parser {
             }
             // '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, ParseError.SelectorExpected, [], [TokenType.ParenthesisR]);
             }
             if (!this.accept(TokenType.ParenthesisR)) {
@@ -1148,6 +1201,16 @@ export class Parser {
         }
         return this.finish(node);
     }
+    _parseScopeSelectorList() {
+        const selectors = this.createNode(nodes.NodeType.SelectorList);
+        if (!selectors.addChild(this._parseSelector(true))) {
+            return null;
+        }
+        while (this.accept(TokenType.Comma) && selectors.addChild(this._parseSelector(true))) {
+            // loop
+        }
+        return this.finish(selectors);
+    }
     _parseMedium() {
         const node = this.create(nodes.Node);
         if (node.addChild(this._parseIdent())) {
@@ -1228,7 +1291,15 @@ export class Parser {
         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(TokenType.Comma)) {
+                if (this.peek(TokenType.CurlyL)) {
+                    break;
+                }
+                node.addChild(this._parseIdent()); // optional container name
+                node.addChild(this._parseContainerQuery());
+            }
+        }
         return this._parseBody(node, this._parseContainerDeclaration.bind(this, isNested));
     }
     _parseContainerQuery() {
@@ -1239,7 +1310,7 @@ export class Parser {
             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());
@@ -1253,7 +1324,7 @@ export class Parser {
         }
         return this.finish(node);
     }
-    _parseContainerQueryInParens() {
+    _parseContainerQueryInParens(optional = false) {
         // <query-in-parens>     = ( <container-query> )
         // 					  | ( <size-feature> )
         // 					  | style( <style-query> )
@@ -1280,6 +1351,9 @@ export class Parser {
             }
         }
         else {
+            if (optional) {
+                return null;
+            }
             return this.finish(node, ParseError.LeftParenthesisExpected, [], [TokenType.CurlyL]);
         }
         return this.finish(node);
@@ -1309,7 +1383,7 @@ export class Parser {
             }
         }
         else {
-            node.addChild(this._parseDeclaration([TokenType.ParenthesisR]));
+            node.addChild(this._parseDeclaration([TokenType.ParenthesisR], true));
         }
         return this.finish(node);
     }
@@ -1815,6 +1889,12 @@ export class Parser {
     _parseFunction() {
         const pos = this.mark();
         const node = this.create(nodes.Function);
+        let parseArgument = this._parseFunctionArgument.bind(this);
+        let separator = TokenType.Comma;
+        if (this.peekIdent("if")) {
+            parseArgument = this._parseIfBranch.bind(this);
+            separator = TokenType.SemiColon;
+        }
         if (!node.setIdentifier(this._parseFunctionIdentifier())) {
             return null;
         }
@@ -1822,12 +1902,12 @@ export class Parser {
             this.restoreAtMark(pos);
             return null;
         }
-        if (node.getArguments().addChild(this._parseFunctionArgument())) {
-            while (this.accept(TokenType.Comma)) {
+        if (node.getArguments().addChild(parseArgument())) {
+            while (this.accept(separator)) {
                 if (this.peek(TokenType.ParenthesisR)) {
                     break;
                 }
-                if (!node.getArguments().addChild(this._parseFunctionArgument())) {
+                if (!node.getArguments().addChild(parseArgument())) {
                     this.markError(node, ParseError.ExpressionExpected);
                 }
             }
@@ -1862,6 +1942,73 @@ export class Parser {
         }
         return null;
     }
+    _parseIfBranch() {
+        // <if-branch> = <if-condition> : <declaration-value>?
+        const node = this.create(nodes.Node);
+        if (!node.addChild(this._parseIfCondition())) {
+            return this.finish(node, ParseError.IfConditionExpected, [], [TokenType.SemiColon]);
+        }
+        if (!this.accept(TokenType.Colon)) {
+            return this.finish(node, ParseError.ColonExpected, [], [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(TokenType.ParenthesisL)) {
+                return this.finish(node, ParseError.LeftParenthesisExpected, [], [TokenType.Colon]);
+            }
+            node.addChild(this._tryToParseDeclaration() || this._parseSupportsCondition());
+            if (!this.accept(TokenType.ParenthesisR)) {
+                return this.finish(node, ParseError.RightParenthesisExpected, [], [TokenType.Colon]);
+            }
+            return this.finish(node);
+        }
+        if (this.acceptIdent('media')) {
+            if (this.hasWhitespace() || !this.accept(TokenType.ParenthesisL)) {
+                return this.finish(node, ParseError.LeftParenthesisExpected, [], [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(TokenType.ParenthesisR)) {
+                return this.finish(node, ParseError.RightParenthesisExpected, [], [TokenType.Colon]);
+            }
+            return this.finish(node);
+        }
+        if (this.acceptIdent('style')) {
+            if (this.hasWhitespace() || !this.accept(TokenType.ParenthesisL)) {
+                return this.finish(node, ParseError.LeftParenthesisExpected, [], [TokenType.Colon]);
+            }
+            node.addChild(this._parseStyleQuery());
+            if (!this.accept(TokenType.ParenthesisR)) {
+                return this.finish(node, ParseError.RightParenthesisExpected, [], [TokenType.Colon]);
+            }
+            return this.finish(node);
+        }
+        return null;
+    }
     _parseHexColor() {
         if (this.peekRegExp(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/esm/parser/cssSymbolScope.js

@@ -3,8 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as nodes from './cssNodes';
-import { findFirst } from '../utils/arrays';
+import * as nodes from './cssNodes.js';
+import { findFirst } from '../utils/arrays.js';
 export class Scope {
     constructor(offset, length) {
         this.offset = offset;

package/lib/esm/parser/lessParser.js

@@ -3,11 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as lessScanner from './lessScanner';
-import { TokenType } from './cssScanner';
-import * as cssParser from './cssParser';
-import * as nodes from './cssNodes';
-import { ParseError } from './cssErrors';
+import * as lessScanner from './lessScanner.js';
+import { TokenType } from './cssScanner.js';
+import * as cssParser from './cssParser.js';
+import * as nodes from './cssNodes.js';
+import { ParseError } from './cssErrors.js';
 /// <summary>
 /// A parser for LESS
 /// http://lesscss.org/

package/lib/esm/parser/lessScanner.js

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as scanner from './cssScanner';
+import * as scanner from './cssScanner.js';
 const _FSL = '/'.charCodeAt(0);
 const _NWL = '\n'.charCodeAt(0);
 const _CAR = '\r'.charCodeAt(0);

package/lib/esm/parser/scssParser.js

@@ -3,12 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as scssScanner from './scssScanner';
-import { TokenType } from './cssScanner';
-import * as cssParser from './cssParser';
-import * as nodes from './cssNodes';
-import { SCSSParseError } from './scssErrors';
-import { ParseError } from './cssErrors';
+import * as scssScanner from './scssScanner.js';
+import { TokenType } from './cssScanner.js';
+import * as cssParser from './cssParser.js';
+import * as nodes from './cssNodes.js';
+import { SCSSParseError } from './scssErrors.js';
+import { ParseError } from './cssErrors.js';
 /// <summary>
 /// A parser for scss
 /// http://sass-lang.com/documentation/file.SASS_REFERENCE.html
@@ -616,6 +616,64 @@ export class SCSSParser extends cssParser.Parser {
     _parseMixinReferenceBodyStatement() {
         return this._tryParseKeyframeSelector() || this._parseRuleSetDeclaration();
     }
+    _parseIfTest() {
+        const node = this.create(nodes.Node);
+        if (this.acceptIdent('sass')) {
+            if (this.hasWhitespace() || !this.accept(TokenType.ParenthesisL)) {
+                return this.finish(node, ParseError.LeftParenthesisExpected, [], [TokenType.CurlyL]);
+            }
+            node.addChild(this._parseExpr());
+            if (!this.accept(TokenType.ParenthesisR)) {
+                return this.finish(node, ParseError.RightParenthesisExpected, [], [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(TokenType.ParenthesisL)) {
+            this.restoreAtMark(pos);
+            return null;
+        }
+        let firstArgument;
+        let parseArgument = this._parseFunctionArgument.bind(this);
+        let separator = 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 = TokenType.SemiColon;
+            }
+            else {
+                this.restoreAtMark(pos);
+                firstArgument = this._parseFunctionArgument();
+            }
+        }
+        if (node.getArguments().addChild(firstArgument)) {
+            while (this.accept(separator)) {
+                if (this.peek(TokenType.ParenthesisR)) {
+                    break;
+                }
+                if (!node.getArguments().addChild(parseArgument())) {
+                    this.markError(node, ParseError.ExpressionExpected);
+                }
+            }
+        }
+        if (!this.accept(TokenType.ParenthesisR)) {
+            return this.finish(node, ParseError.RightParenthesisExpected);
+        }
+        return this.finish(node);
+    }
     _parseFunctionArgument() {
         // [variableName ':'] expression | variableName '...'
         const node = this.create(nodes.FunctionArgument);

package/lib/esm/parser/scssScanner.js

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { TokenType, Scanner } from './cssScanner';
+import { TokenType, Scanner } from './cssScanner.js';
 const _FSL = '/'.charCodeAt(0);
 const _NWL = '\n'.charCodeAt(0);
 const _CAR = '\r'.charCodeAt(0);

package/lib/esm/services/cssCodeActions.js

@@ -3,10 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as nodes from '../parser/cssNodes';
-import { difference } from '../utils/strings';
-import { Rules } from '../services/lintRules';
-import { Command, TextEdit, CodeAction, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier } from '../cssLanguageTypes';
+import * as nodes from '../parser/cssNodes.js';
+import { difference } from '../utils/strings.js';
+import { Rules } from '../services/lintRules.js';
+import { Command, TextEdit, CodeAction, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier } from '../cssLanguageTypes.js';
 import * as l10n from '@vscode/l10n';
 export class CSSCodeActions {
     constructor(cssDataManager) {

package/lib/esm/services/cssCompletion.js

@@ -3,14 +3,14 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as nodes from '../parser/cssNodes';
-import { Symbols } from '../parser/cssSymbolScope';
-import * as languageFacts from '../languageFacts/facts';
-import * as strings from '../utils/strings';
-import { Position, CompletionItemKind, Range, TextEdit, InsertTextFormat, MarkupKind, CompletionItemTag } from '../cssLanguageTypes';
+import * as nodes from '../parser/cssNodes.js';
+import { Symbols } from '../parser/cssSymbolScope.js';
+import * as languageFacts from '../languageFacts/facts.js';
+import * as strings from '../utils/strings.js';
+import { Position, CompletionItemKind, Range, TextEdit, InsertTextFormat, MarkupKind, CompletionItemTag } from '../cssLanguageTypes.js';
 import * as l10n from '@vscode/l10n';
-import { isDefined } from '../utils/objects';
-import { PathCompletionParticipant } from './pathCompletion';
+import { isDefined } from '../utils/objects.js';
+import { PathCompletionParticipant } from './pathCompletion.js';
 const SnippetFormat = InsertTextFormat.Snippet;
 const retriggerCommand = {
     title: 'Suggest',

package/lib/esm/services/cssFolding.js

@@ -3,9 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { TokenType, Scanner } from '../parser/cssScanner';
-import { SCSSScanner, InterpolationFunction } from '../parser/scssScanner';
-import { LESSScanner } from '../parser/lessScanner';
+import { TokenType, Scanner } from '../parser/cssScanner.js';
+import { SCSSScanner, InterpolationFunction } from '../parser/scssScanner.js';
+import { LESSScanner } from '../parser/lessScanner.js';
 export function getFoldingRanges(document, context) {
     const ranges = computeFoldingRanges(document);
     return limitFoldingRanges(ranges, context);

package/lib/esm/services/cssFormatter.js

@@ -2,9 +2,9 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { Range, Position } from '../cssLanguageTypes';
-import { css_beautify } from '../beautify/beautify-css';
-import { repeat } from '../utils/strings';
+import { Range, Position } from '../cssLanguageTypes.js';
+import { css_beautify } from '../beautify/beautify-css.js';
+import { repeat } from '../utils/strings.js';
 export function format(document, range, options) {
     let value = document.getText();
     let includesEnd = true;

package/lib/esm/services/cssHover.js

@@ -3,12 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as nodes from '../parser/cssNodes';
-import * as languageFacts from '../languageFacts/facts';
-import { SelectorPrinting } from './selectorPrinting';
-import { startsWith } from '../utils/strings';
-import { Range, MarkupKind } from '../cssLanguageTypes';
-import { isDefined } from '../utils/objects';
+import * as nodes from '../parser/cssNodes.js';
+import * as languageFacts from '../languageFacts/facts.js';
+import { SelectorPrinting } from './selectorPrinting.js';
+import { startsWith } from '../utils/strings.js';
+import { Range, MarkupKind } from '../cssLanguageTypes.js';
+import { isDefined } from '../utils/objects.js';
 export class CSSHover {
     constructor(clientCapabilities, cssDataManager) {
         this.clientCapabilities = clientCapabilities;

package/lib/esm/services/cssNavigation.js

@@ -3,13 +3,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { DocumentHighlightKind, Location, Range, SymbolKind, TextEdit, FileType } from '../cssLanguageTypes';
+import { DocumentHighlightKind, Location, Range, SymbolKind, TextEdit, FileType } from '../cssLanguageTypes.js';
 import * as l10n from '@vscode/l10n';
-import * as nodes from '../parser/cssNodes';
-import { Symbols } from '../parser/cssSymbolScope';
-import { getColorValue, hslFromColor, hwbFromColor, labFromColor, lchFromColor, oklabFromColor, oklchFromColor, } from '../languageFacts/facts';
-import { startsWith } from '../utils/strings';
-import { dirname, joinPath } from '../utils/resources';
+import * as nodes from '../parser/cssNodes.js';
+import { Symbols } from '../parser/cssSymbolScope.js';
+import { getColorValue, hslFromColor, hwbFromColor, labFromColor, lchFromColor, oklabFromColor, oklchFromColor, } from '../languageFacts/facts.js';
+import { startsWith } from '../utils/strings.js';
+import { dirname, joinPath } from '../utils/resources.js';
 const startsWithSchemeRegex = /^\w+:\/\//;
 const startsWithData = /^data:/;
 export class CSSNavigation {

package/lib/esm/services/cssSelectionRange.js

@@ -3,8 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { Range, SelectionRange } from '../cssLanguageTypes';
-import { NodeType } from '../parser/cssNodes';
+import { Range, SelectionRange } from '../cssLanguageTypes.js';
+import { NodeType } from '../parser/cssNodes.js';
 export function getSelectionRanges(document, positions, stylesheet) {
     function getSelectionRange(position) {
         const applicableRanges = getApplicableRanges(position);

package/lib/esm/services/cssValidation.js

@@ -3,10 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as nodes from '../parser/cssNodes';
-import { LintConfigurationSettings, Rules } from './lintRules';
-import { LintVisitor } from './lint';
-import { Range, DiagnosticSeverity } from '../cssLanguageTypes';
+import * as nodes from '../parser/cssNodes.js';
+import { LintConfigurationSettings, Rules } from './lintRules.js';
+import { LintVisitor } from './lint.js';
+import { Range, DiagnosticSeverity } from '../cssLanguageTypes.js';
 export class CSSValidation {
     constructor(cssDataManager) {
         this.cssDataManager = cssDataManager;

package/lib/esm/services/lessCompletion.js

@@ -3,8 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import { CSSCompletion } from './cssCompletion';
-import { CompletionItemKind, InsertTextFormat, TextEdit } from '../cssLanguageTypes';
+import { CSSCompletion } from './cssCompletion.js';
+import { CompletionItemKind, InsertTextFormat, TextEdit } from '../cssLanguageTypes.js';
 import * as l10n from '@vscode/l10n';
 export class LESSCompletion extends CSSCompletion {
     constructor(lsOptions, cssDataManager) {