vscode-css-languageservice 5.1.9 → 5.1.13

package/lib/esm/languageFacts/colors.js

@@ -9,7 +9,8 @@ export var colorFunctions = [
     { func: 'rgb($red, $green, $blue)', desc: localize('css.builtin.rgb', 'Creates a Color from red, green, and blue values.') },
     { func: 'rgba($red, $green, $blue, $alpha)', desc: localize('css.builtin.rgba', 'Creates a Color from red, green, blue, and alpha values.') },
     { func: 'hsl($hue, $saturation, $lightness)', desc: localize('css.builtin.hsl', 'Creates a Color from hue, saturation, and lightness values.') },
-    { func: 'hsla($hue, $saturation, $lightness, $alpha)', desc: localize('css.builtin.hsla', 'Creates a Color from hue, saturation, lightness, and alpha values.') }
+    { func: 'hsla($hue, $saturation, $lightness, $alpha)', desc: localize('css.builtin.hsla', 'Creates a Color from hue, saturation, lightness, and alpha values.') },
+    { func: 'hwb($hue $white $black)', desc: localize('css.builtin.hwb', 'Creates a Color from hue, white and black.') }
 ];
 export var colors = {
     aliceblue: '#f0f8ff',
@@ -181,9 +182,22 @@ function getNumericValue(node, factor) {
 }
 function getAngle(node) {
     var val = node.getText();
-    var m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(deg)?$/);
+    var m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(deg|rad|grad|turn)?$/);
     if (m) {
-        return parseFloat(val) % 360;
+        switch (m[2]) {
+            case 'deg':
+                return parseFloat(val) % 360;
+            case 'rad':
+                return (parseFloat(val) * 180 / Math.PI) % 360;
+            case 'grad':
+                return (parseFloat(val) * 0.9) % 360;
+            case 'turn':
+                return (parseFloat(val) * 360) % 360;
+            default:
+                if ('undefined' === typeof m[2]) {
+                    return parseFloat(val) % 360;
+                }
+        }
     }
     throw new Error();
 }
@@ -192,7 +206,7 @@ export function isColorConstructor(node) {
     if (!name) {
         return false;
     }
-    return /^(rgb|rgba|hsl|hsla)$/gi.test(name);
+    return /^(rgb|rgba|hsl|hsla|hwb)$/gi.test(name);
 }
 /**
  * Returns true if the node is a color value - either
@@ -345,6 +359,40 @@ export function hslFromColor(rgba) {
     }
     return { h: h, s: s, l: l, a: a };
 }
+export function colorFromHWB(hue, white, black, alpha) {
+    if (alpha === void 0) { alpha = 1.0; }
+    if (white + black >= 1) {
+        var gray = white / (white + black);
+        return { red: gray, green: gray, blue: gray, alpha: alpha };
+    }
+    var rgb = colorFromHSL(hue, 1, 0.5, alpha);
+    var red = rgb.red;
+    red *= (1 - white - black);
+    red += white;
+    var green = rgb.green;
+    green *= (1 - white - black);
+    green += white;
+    var blue = rgb.blue;
+    blue *= (1 - white - black);
+    blue += white;
+    return {
+        red: red,
+        green: green,
+        blue: blue,
+        alpha: alpha
+    };
+}
+export function hwbFromColor(rgba) {
+    var hsl = hslFromColor(rgba);
+    var white = Math.min(rgba.red, rgba.green, rgba.blue);
+    var black = 1 - Math.max(rgba.red, rgba.green, rgba.blue);
+    return {
+        h: hsl.h,
+        w: white,
+        b: black,
+        a: hsl.a
+    };
+}
 export function getColorValue(node) {
     if (node.type === nodes.NodeType.HexColorValue) {
         var text = node.getText();
@@ -388,6 +436,12 @@ export function getColorValue(node) {
                 var l = getNumericValue(colorValues[2], 100.0);
                 return colorFromHSL(h, s, l, alpha);
             }
+            else if (name === 'hwb') {
+                var h = getAngle(colorValues[0]);
+                var w = getNumericValue(colorValues[1], 100.0);
+                var b = getNumericValue(colorValues[2], 100.0);
+                return colorFromHWB(h, w, b, alpha);
+            }
         }
         catch (e) {
             // parse error on numeric value

package/lib/esm/languageFacts/entry.js

@@ -65,7 +65,7 @@ function getEntryStringDescription(entry, settings) {
             result += '\n(' + browserLabel + ')';
         }
         if ('syntax' in entry) {
-            result += "\n\nSyntax: " + entry.syntax;
+            result += "\n\nSyntax: ".concat(entry.syntax);
         }
     }
     if (entry.references && entry.references.length > 0 && (settings === null || settings === void 0 ? void 0 : settings.references) !== false) {
@@ -73,7 +73,7 @@ function getEntryStringDescription(entry, settings) {
             result += '\n\n';
         }
         result += entry.references.map(function (r) {
-            return r.name + ": " + r.url;
+            return "".concat(r.name, ": ").concat(r.url);
         }).join(' | ');
     }
     return result;
@@ -98,7 +98,7 @@ function getEntryMarkdownDescription(entry, settings) {
             result += '\n\n(' + textToMarkedString(browserLabel) + ')';
         }
         if ('syntax' in entry && entry.syntax) {
-            result += "\n\nSyntax: " + textToMarkedString(entry.syntax);
+            result += "\n\nSyntax: ".concat(textToMarkedString(entry.syntax));
         }
     }
     if (entry.references && entry.references.length > 0 && (settings === null || settings === void 0 ? void 0 : settings.references) !== false) {
@@ -106,7 +106,7 @@ function getEntryMarkdownDescription(entry, settings) {
             result += '\n\n';
         }
         result += entry.references.map(function (r) {
-            return "[" + r.name + "](" + r.url + ")";
+            return "[".concat(r.name, "](").concat(r.url, ")");
         }).join(' | ');
     }
     return result;

package/lib/esm/parser/cssParser.js

@@ -1259,6 +1259,7 @@ var Parser = /** @class */ (function () {
         if (node.setOperator(this._parseOperator())) {
             node.setValue(this._parseBinaryExpr());
             this.acceptIdent('i'); // case insensitive matching
+            this.acceptIdent('s'); // case sensitive matching
         }
         if (!this.accept(TokenType.BracketR)) {
             return this.finish(node, ParseError.RightSquareBracketExpected);

package/lib/esm/services/cssCompletion.js

@@ -457,7 +457,7 @@ var CSSCompletion = /** @class */ (function () {
         var symbols = this.getSymbolContext().findSymbolsAtOffset(this.offset, nodes.ReferenceType.Variable);
         for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
             var symbol = symbols_1[_i];
-            var insertText = strings.startsWith(symbol.name, '--') ? "var(" + symbol.name + ")" : symbol.name;
+            var insertText = strings.startsWith(symbol.name, '--') ? "var(".concat(symbol.name, ")") : symbol.name;
             var completionItem = {
                 label: symbol.name,
                 documentation: symbol.value ? strings.getLimitedString(symbol.value) : symbol.value,

package/lib/esm/services/cssNavigation.js

@@ -43,15 +43,16 @@ import { DocumentHighlightKind, Location, Range, SymbolKind, TextEdit, FileType
 import * as nls from 'vscode-nls';
 import * as nodes from '../parser/cssNodes';
 import { Symbols } from '../parser/cssSymbolScope';
-import { getColorValue, hslFromColor } from '../languageFacts/facts';
+import { getColorValue, hslFromColor, hwbFromColor } from '../languageFacts/facts';
 import { startsWith } from '../utils/strings';
 import { dirname, joinPath } from '../utils/resources';
 var localize = nls.loadMessageBundle();
 var startsWithSchemeRegex = /^\w+:\/\//;
 var startsWithData = /^data:/;
 var CSSNavigation = /** @class */ (function () {
-    function CSSNavigation(fileSystemProvider) {
+    function CSSNavigation(fileSystemProvider, resolveModuleReferences) {
         this.fileSystemProvider = fileSystemProvider;
+        this.resolveModuleReferences = resolveModuleReferences;
     }
     CSSNavigation.prototype.findDefinition = function (document, position, stylesheet) {
         var symbols = new Symbols(stylesheet);
@@ -281,25 +282,33 @@ var CSSNavigation = /** @class */ (function () {
         var red256 = Math.round(color.red * 255), green256 = Math.round(color.green * 255), blue256 = Math.round(color.blue * 255);
         var label;
         if (color.alpha === 1) {
-            label = "rgb(" + red256 + ", " + green256 + ", " + blue256 + ")";
+            label = "rgb(".concat(red256, ", ").concat(green256, ", ").concat(blue256, ")");
         }
         else {
-            label = "rgba(" + red256 + ", " + green256 + ", " + blue256 + ", " + color.alpha + ")";
+            label = "rgba(".concat(red256, ", ").concat(green256, ", ").concat(blue256, ", ").concat(color.alpha, ")");
         }
         result.push({ label: label, textEdit: TextEdit.replace(range, label) });
         if (color.alpha === 1) {
-            label = "#" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256);
+            label = "#".concat(toTwoDigitHex(red256)).concat(toTwoDigitHex(green256)).concat(toTwoDigitHex(blue256));
         }
         else {
-            label = "#" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256) + toTwoDigitHex(Math.round(color.alpha * 255));
+            label = "#".concat(toTwoDigitHex(red256)).concat(toTwoDigitHex(green256)).concat(toTwoDigitHex(blue256)).concat(toTwoDigitHex(Math.round(color.alpha * 255)));
         }
         result.push({ label: label, textEdit: TextEdit.replace(range, label) });
         var hsl = hslFromColor(color);
         if (hsl.a === 1) {
-            label = "hsl(" + hsl.h + ", " + Math.round(hsl.s * 100) + "%, " + Math.round(hsl.l * 100) + "%)";
+            label = "hsl(".concat(hsl.h, ", ").concat(Math.round(hsl.s * 100), "%, ").concat(Math.round(hsl.l * 100), "%)");
         }
         else {
-            label = "hsla(" + hsl.h + ", " + Math.round(hsl.s * 100) + "%, " + Math.round(hsl.l * 100) + "%, " + hsl.a + ")";
+            label = "hsla(".concat(hsl.h, ", ").concat(Math.round(hsl.s * 100), "%, ").concat(Math.round(hsl.l * 100), "%, ").concat(hsl.a, ")");
+        }
+        result.push({ label: label, textEdit: TextEdit.replace(range, label) });
+        var hwb = hwbFromColor(color);
+        if (hwb.a === 1) {
+            label = "hwb(".concat(hwb.h, " ").concat(Math.round(hwb.w * 100), "% ").concat(Math.round(hwb.b * 100), "%)");
+        }
+        else {
+            label = "hwb(".concat(hwb.h, " ").concat(Math.round(hwb.w * 100), "% ").concat(Math.round(hwb.b * 100), "% / ").concat(hwb.a, ")");
         }
         result.push({ label: label, textEdit: TextEdit.replace(range, label) });
         return result;
@@ -312,14 +321,12 @@ var CSSNavigation = /** @class */ (function () {
             changes: (_a = {}, _a[document.uri] = edits, _a)
         };
     };
-    CSSNavigation.prototype.resolveRelativeReference = function (ref, documentUri, documentContext, isRawLink) {
+    CSSNavigation.prototype.resolveModuleReference = function (ref, documentUri, documentContext) {
         return __awaiter(this, void 0, void 0, function () {
             var moduleName, rootFolderUri, documentFolderUri, modulePath, pathWithinModule;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(ref[0] === '~' && ref[1] !== '/' && this.fileSystemProvider)) return [3 /*break*/, 3];
-                        ref = ref.substring(1);
                         if (!startsWith(documentUri, 'file://')) return [3 /*break*/, 2];
                         moduleName = getModuleNameFromPath(ref);
                         rootFolderUri = documentContext.resolveReference('/', documentUri);
@@ -332,8 +339,36 @@ var CSSNavigation = /** @class */ (function () {
                             return [2 /*return*/, joinPath(modulePath, pathWithinModule)];
                         }
                         _a.label = 2;
-                    case 2: return [2 /*return*/, documentContext.resolveReference(ref, documentUri)];
-                    case 3: return [2 /*return*/, documentContext.resolveReference(ref, documentUri)];
+                    case 2: return [2 /*return*/, undefined];
+                }
+            });
+        });
+    };
+    CSSNavigation.prototype.resolveRelativeReference = function (ref, documentUri, documentContext, isRawLink) {
+        return __awaiter(this, void 0, void 0, function () {
+            var relativeReference, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        relativeReference = documentContext.resolveReference(ref, documentUri);
+                        if (!(ref[0] === '~' && ref[1] !== '/' && this.fileSystemProvider)) return [3 /*break*/, 2];
+                        ref = ref.substring(1);
+                        return [4 /*yield*/, this.resolveModuleReference(ref, documentUri, documentContext)];
+                    case 1: return [2 /*return*/, (_b.sent()) || relativeReference];
+                    case 2:
+                        if (!this.resolveModuleReferences) return [3 /*break*/, 7];
+                        _a = relativeReference;
+                        if (!_a) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.fileExists(relativeReference)];
+                    case 3:
+                        _a = (_b.sent());
+                        _b.label = 4;
+                    case 4:
+                        if (!_a) return [3 /*break*/, 5];
+                        return [2 /*return*/, relativeReference];
+                    case 5: return [4 /*yield*/, this.resolveModuleReference(ref, documentUri, documentContext)];
+                    case 6: return [2 /*return*/, (_b.sent()) || relativeReference];
+                    case 7: return [2 /*return*/, relativeReference];
                 }
             });
         });

package/lib/esm/services/lint.js

@@ -162,7 +162,7 @@ var LintVisitor = /** @class */ (function () {
         if (atDirective) {
             return false;
         }
-        this.addEntry(atRuleName, Rules.UnknownAtRules, "Unknown at rule " + atRuleName.getText());
+        this.addEntry(atRuleName, Rules.UnknownAtRules, "Unknown at rule ".concat(atRuleName.getText()));
         return true;
     };
     LintVisitor.prototype.visitKeyframe = function (node) {

package/lib/esm/services/scssCompletion.js

@@ -44,7 +44,7 @@ var SCSSCompletion = /** @class */ (function (_super) {
                 var item = {
                     label: p.label,
                     documentation: p.documentation,
-                    textEdit: TextEdit.replace(this.getCompletionRange(importPathNode), "'" + p.label + "'"),
+                    textEdit: TextEdit.replace(this.getCompletionRange(importPathNode), "'".concat(p.label, "'")),
                     kind: CompletionItemKind.Module
                 };
                 result.items.push(item);
@@ -369,7 +369,7 @@ function addReferencesToDocumentation(items) {
             markdownDoc.value += '\n\n';
             markdownDoc.value += i.references
                 .map(function (r) {
-                return "[" + r.name + "](" + r.url + ")";
+                return "[".concat(r.name, "](").concat(r.url, ")");
             })
                 .join(' | ');
             i.documentation = markdownDoc;

package/lib/esm/services/scssNavigation.js

@@ -61,7 +61,7 @@ import { startsWith } from '../utils/strings';
 var SCSSNavigation = /** @class */ (function (_super) {
     __extends(SCSSNavigation, _super);
     function SCSSNavigation(fileSystemProvider) {
-        return _super.call(this, fileSystemProvider) || this;
+        return _super.call(this, fileSystemProvider, true) || this;
     }
     SCSSNavigation.prototype.isRawStringDocumentLinkNode = function (node) {
         return (_super.prototype.isRawStringDocumentLinkNode.call(this, node) ||

package/lib/esm/services/selectorPrinting.js

@@ -291,23 +291,23 @@ export function toElement(node, parentElement) {
                         switch (unescape(operator.getText())) {
                             case '|=':
                                 // excatly or followed by -words
-                                value = quotes.remove(unescape(expression.getText())) + "-\u2026";
+                                value = "".concat(quotes.remove(unescape(expression.getText())), "-\u2026");
                                 break;
                             case '^=':
                                 // prefix
-                                value = quotes.remove(unescape(expression.getText())) + "\u2026";
+                                value = "".concat(quotes.remove(unescape(expression.getText())), "\u2026");
                                 break;
                             case '$=':
                                 // suffix
-                                value = "\u2026" + quotes.remove(unescape(expression.getText()));
+                                value = "\u2026".concat(quotes.remove(unescape(expression.getText())));
                                 break;
                             case '~=':
                                 // one of a list of words
-                                value = " \u2026 " + quotes.remove(unescape(expression.getText())) + " \u2026 ";
+                                value = " \u2026 ".concat(quotes.remove(unescape(expression.getText())), " \u2026 ");
                                 break;
                             case '*=':
                                 // substring
-                                value = "\u2026" + quotes.remove(unescape(expression.getText())) + "\u2026";
+                                value = "\u2026".concat(quotes.remove(unescape(expression.getText())), "\u2026");
                                 break;
                             default:
                                 value = quotes.remove(unescape(expression.getText()));
@@ -362,7 +362,8 @@ var SelectorPrinting = /** @class */ (function () {
         var _this = this;
         //https://www.w3.org/TR/selectors-3/#specificity
         var calculateScore = function (node) {
-            for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
+            var specificity = new Specificity();
+            elementLoop: for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
                 var element = _a[_i];
                 switch (element.type) {
                     case nodes.NodeType.IdentifierSelector:
@@ -383,23 +384,66 @@ var SelectorPrinting = /** @class */ (function () {
                         var text = element.getText();
                         if (_this.isPseudoElementIdentifier(text)) {
                             specificity.tag++; // pseudo element
+                            break;
                         }
-                        else {
-                            //ignore psuedo class NOT
-                            if (text.match(/^:not/i)) {
-                                break;
+                        // where and child selectors have zero specificity
+                        if (text.match(/^:where/i)) {
+                            continue elementLoop;
+                        }
+                        // the most specific child selector
+                        if (text.match(/^:(not|has|is)/i) && element.getChildren().length > 0) {
+                            var mostSpecificListItem = new Specificity();
+                            for (var _b = 0, _c = element.getChildren(); _b < _c.length; _b++) {
+                                var containerElement = _c[_b];
+                                var list = void 0;
+                                if (containerElement.type === nodes.NodeType.Undefined) { // containerElement is a list of selectors
+                                    list = containerElement.getChildren();
+                                }
+                                else { // containerElement is a selector
+                                    list = [containerElement];
+                                }
+                                for (var _d = 0, _e = containerElement.getChildren(); _d < _e.length; _d++) {
+                                    var childElement = _e[_d];
+                                    var itemSpecificity = calculateScore(childElement);
+                                    if (itemSpecificity.id > mostSpecificListItem.id) {
+                                        mostSpecificListItem = itemSpecificity;
+                                        continue;
+                                    }
+                                    else if (itemSpecificity.id < mostSpecificListItem.id) {
+                                        continue;
+                                    }
+                                    if (itemSpecificity.attr > mostSpecificListItem.attr) {
+                                        mostSpecificListItem = itemSpecificity;
+                                        continue;
+                                    }
+                                    else if (itemSpecificity.attr < mostSpecificListItem.attr) {
+                                        continue;
+                                    }
+                                    if (itemSpecificity.tag > mostSpecificListItem.tag) {
+                                        mostSpecificListItem = itemSpecificity;
+                                        continue;
+                                    }
+                                }
                             }
-                            specificity.attr++; //pseudo class
+                            specificity.id += mostSpecificListItem.id;
+                            specificity.attr += mostSpecificListItem.attr;
+                            specificity.tag += mostSpecificListItem.tag;
+                            continue elementLoop;
                         }
+                        specificity.attr++; //pseudo class
                         break;
                 }
                 if (element.getChildren().length > 0) {
-                    calculateScore(element);
+                    var itemSpecificity = calculateScore(element);
+                    specificity.id += itemSpecificity.id;
+                    specificity.attr += itemSpecificity.attr;
+                    specificity.tag += itemSpecificity.tag;
                 }
             }
+            return specificity;
         };
-        var specificity = new Specificity();
-        calculateScore(node);
+        var specificity = calculateScore(node);
+        ;
         return localize('specificity', "[Selector Specificity](https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity): ({0}, {1}, {2})", specificity.id, specificity.attr, specificity.tag);
     };
     return SelectorPrinting;

package/lib/umd/cssLanguageService.js

@@ -82,7 +82,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     function getCSSLanguageService(options) {
         if (options === void 0) { options = defaultLanguageServiceOptions; }
         var cssDataManager = new dataManager_1.CSSDataManager(options);
-        return createFacade(new cssParser_1.Parser(), new cssCompletion_1.CSSCompletion(null, options, cssDataManager), new cssHover_1.CSSHover(options && options.clientCapabilities, cssDataManager), new cssNavigation_1.CSSNavigation(options && options.fileSystemProvider), new cssCodeActions_1.CSSCodeActions(cssDataManager), new cssValidation_1.CSSValidation(cssDataManager), cssDataManager);
+        return createFacade(new cssParser_1.Parser(), new cssCompletion_1.CSSCompletion(null, options, cssDataManager), new cssHover_1.CSSHover(options && options.clientCapabilities, cssDataManager), new cssNavigation_1.CSSNavigation(options && options.fileSystemProvider, false), new cssCodeActions_1.CSSCodeActions(cssDataManager), new cssValidation_1.CSSValidation(cssDataManager), cssDataManager);
     }
     exports.getCSSLanguageService = getCSSLanguageService;
     function getSCSSLanguageService(options) {
@@ -94,7 +94,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     function getLESSLanguageService(options) {
         if (options === void 0) { options = defaultLanguageServiceOptions; }
         var cssDataManager = new dataManager_1.CSSDataManager(options);
-        return createFacade(new lessParser_1.LESSParser(), new lessCompletion_1.LESSCompletion(options, cssDataManager), new cssHover_1.CSSHover(options && options.clientCapabilities, cssDataManager), new cssNavigation_1.CSSNavigation(options && options.fileSystemProvider), new cssCodeActions_1.CSSCodeActions(cssDataManager), new cssValidation_1.CSSValidation(cssDataManager), cssDataManager);
+        return createFacade(new lessParser_1.LESSParser(), new lessCompletion_1.LESSCompletion(options, cssDataManager), new cssHover_1.CSSHover(options && options.clientCapabilities, cssDataManager), new cssNavigation_1.CSSNavigation(options && options.fileSystemProvider, true), new cssCodeActions_1.CSSCodeActions(cssDataManager), new cssValidation_1.CSSValidation(cssDataManager), cssDataManager);
     }
     exports.getLESSLanguageService = getLESSLanguageService;
 });