vscode-css-languageservice 6.1.1 → 6.2.1

package/lib/umd/services/lessCompletion.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./cssCompletion", "../cssLanguageTypes", "vscode-nls"], factory);
+        define(["require", "exports", "./cssCompletion", "../cssLanguageTypes", "@vscode/l10n"], factory);
     }
 })(function (require, exports) {
     /*---------------------------------------------------------------------------------------------
@@ -16,8 +16,7 @@
     exports.LESSCompletion = void 0;
     const cssCompletion_1 = require("./cssCompletion");
     const cssLanguageTypes_1 = require("../cssLanguageTypes");
-    const nls = require("vscode-nls");
-    const localize = nls.loadMessageBundle();
+    const l10n = require("@vscode/l10n");
     class LESSCompletion extends cssCompletion_1.CSSCompletion {
         constructor(lsOptions, cssDataManager) {
             super('@', lsOptions, cssDataManager);
@@ -62,156 +61,156 @@
         {
             'name': 'if',
             'example': 'if(condition, trueValue [, falseValue]);',
-            'description': localize('less.builtin.if', 'returns one of two values depending on a condition.')
+            'description': l10n.t('returns one of two values depending on a condition.')
         },
         {
             'name': 'boolean',
             'example': 'boolean(condition);',
-            'description': localize('less.builtin.boolean', '"store" a boolean test for later evaluation in a guard or if().')
+            'description': l10n.t('"store" a boolean test for later evaluation in a guard or if().')
         },
         // List functions
         {
             'name': 'length',
             'example': 'length(@list);',
-            'description': localize('less.builtin.length', 'returns the number of elements in a value list')
+            'description': l10n.t('returns the number of elements in a value list')
         },
         {
             'name': 'extract',
             'example': 'extract(@list, index);',
-            'description': localize('less.builtin.extract', 'returns a value at the specified position in the list')
+            'description': l10n.t('returns a value at the specified position in the list')
         },
         {
             'name': 'range',
             'example': 'range([start, ] end [, step]);',
-            'description': localize('less.builtin.range', 'generate a list spanning a range of values')
+            'description': l10n.t('generate a list spanning a range of values')
         },
         {
             'name': 'each',
             'example': 'each(@list, ruleset);',
-            'description': localize('less.builtin.each', 'bind the evaluation of a ruleset to each member of a list.')
+            'description': l10n.t('bind the evaluation of a ruleset to each member of a list.')
         },
         // Other built-ins
         {
             'name': 'escape',
             'example': 'escape(@string);',
-            'description': localize('less.builtin.escape', 'URL encodes a string')
+            'description': l10n.t('URL encodes a string')
         },
         {
             'name': 'e',
             'example': 'e(@string);',
-            'description': localize('less.builtin.e', 'escape string content')
+            'description': l10n.t('escape string content')
         },
         {
             'name': 'replace',
             'example': 'replace(@string, @pattern, @replacement[, @flags]);',
-            'description': localize('less.builtin.replace', 'string replace')
+            'description': l10n.t('string replace')
         },
         {
             'name': 'unit',
             'example': 'unit(@dimension, [@unit: \'\']);',
-            'description': localize('less.builtin.unit', 'remove or change the unit of a dimension')
+            'description': l10n.t('remove or change the unit of a dimension')
         },
         {
             'name': 'color',
             'example': 'color(@string);',
-            'description': localize('less.builtin.color', 'parses a string to a color'),
+            'description': l10n.t('parses a string to a color'),
             'type': 'color'
         },
         {
             'name': 'convert',
             'example': 'convert(@value, unit);',
-            'description': localize('less.builtin.convert', 'converts numbers from one type into another')
+            'description': l10n.t('converts numbers from one type into another')
         },
         {
             'name': 'data-uri',
             'example': 'data-uri([mimetype,] url);',
-            'description': localize('less.builtin.data-uri', 'inlines a resource and falls back to `url()`'),
+            'description': l10n.t('inlines a resource and falls back to `url()`'),
             'type': 'url'
         },
         {
             'name': 'abs',
-            'description': localize('less.builtin.abs', 'absolute value of a number'),
+            'description': l10n.t('absolute value of a number'),
             'example': 'abs(number);'
         },
         {
             'name': 'acos',
-            'description': localize('less.builtin.acos', 'arccosine - inverse of cosine function'),
+            'description': l10n.t('arccosine - inverse of cosine function'),
             'example': 'acos(number);'
         },
         {
             'name': 'asin',
-            'description': localize('less.builtin.asin', 'arcsine - inverse of sine function'),
+            'description': l10n.t('arcsine - inverse of sine function'),
             'example': 'asin(number);'
         },
         {
             'name': 'ceil',
             'example': 'ceil(@number);',
-            'description': localize('less.builtin.ceil', 'rounds up to an integer')
+            'description': l10n.t('rounds up to an integer')
         },
         {
             'name': 'cos',
-            'description': localize('less.builtin.cos', 'cosine function'),
+            'description': l10n.t('cosine function'),
             'example': 'cos(number);'
         },
         {
             'name': 'floor',
-            'description': localize('less.builtin.floor', 'rounds down to an integer'),
+            'description': l10n.t('rounds down to an integer'),
             'example': 'floor(@number);'
         },
         {
             'name': 'percentage',
-            'description': localize('less.builtin.percentage', 'converts to a %, e.g. 0.5 > 50%'),
+            'description': l10n.t('converts to a %, e.g. 0.5 > 50%'),
             'example': 'percentage(@number);',
             'type': 'percentage'
         },
         {
             'name': 'round',
-            'description': localize('less.builtin.round', 'rounds a number to a number of places'),
+            'description': l10n.t('rounds a number to a number of places'),
             'example': 'round(number, [places: 0]);'
         },
         {
             'name': 'sqrt',
-            'description': localize('less.builtin.sqrt', 'calculates square root of a number'),
+            'description': l10n.t('calculates square root of a number'),
             'example': 'sqrt(number);'
         },
         {
             'name': 'sin',
-            'description': localize('less.builtin.sin', 'sine function'),
+            'description': l10n.t('sine function'),
             'example': 'sin(number);'
         },
         {
             'name': 'tan',
-            'description': localize('less.builtin.tan', 'tangent function'),
+            'description': l10n.t('tangent function'),
             'example': 'tan(number);'
         },
         {
             'name': 'atan',
-            'description': localize('less.builtin.atan', 'arctangent - inverse of tangent function'),
+            'description': l10n.t('arctangent - inverse of tangent function'),
             'example': 'atan(number);'
         },
         {
             'name': 'pi',
-            'description': localize('less.builtin.pi', 'returns pi'),
+            'description': l10n.t('returns pi'),
             'example': 'pi();'
         },
         {
             'name': 'pow',
-            'description': localize('less.builtin.pow', 'first argument raised to the power of the second argument'),
+            'description': l10n.t('first argument raised to the power of the second argument'),
             'example': 'pow(@base, @exponent);'
         },
         {
             'name': 'mod',
-            'description': localize('less.builtin.mod', 'first argument modulus second argument'),
+            'description': l10n.t('first argument modulus second argument'),
             'example': 'mod(number, number);'
         },
         {
             'name': 'min',
-            'description': localize('less.builtin.min', 'returns the lowest of one or more values'),
+            'description': l10n.t('returns the lowest of one or more values'),
             'example': 'min(@x, @y);'
         },
         {
             'name': 'max',
-            'description': localize('less.builtin.max', 'returns the lowest of one or more values'),
+            'description': l10n.t('returns the lowest of one or more values'),
             'example': 'max(@x, @y);'
         }
     ];
@@ -219,137 +218,137 @@
         {
             'name': 'argb',
             'example': 'argb(@color);',
-            'description': localize('less.builtin.argb', 'creates a #AARRGGBB')
+            'description': l10n.t('creates a #AARRGGBB')
         },
         {
             'name': 'hsl',
             'example': 'hsl(@hue, @saturation, @lightness);',
-            'description': localize('less.builtin.hsl', 'creates a color')
+            'description': l10n.t('creates a color')
         },
         {
             'name': 'hsla',
             'example': 'hsla(@hue, @saturation, @lightness, @alpha);',
-            'description': localize('less.builtin.hsla', 'creates a color')
+            'description': l10n.t('creates a color')
         },
         {
             'name': 'hsv',
             'example': 'hsv(@hue, @saturation, @value);',
-            'description': localize('less.builtin.hsv', 'creates a color')
+            'description': l10n.t('creates a color')
         },
         {
             'name': 'hsva',
             'example': 'hsva(@hue, @saturation, @value, @alpha);',
-            'description': localize('less.builtin.hsva', 'creates a color')
+            'description': l10n.t('creates a color')
         },
         {
             'name': 'hue',
             'example': 'hue(@color);',
-            'description': localize('less.builtin.hue', 'returns the `hue` channel of `@color` in the HSL space')
+            'description': l10n.t('returns the `hue` channel of `@color` in the HSL space')
         },
         {
             'name': 'saturation',
             'example': 'saturation(@color);',
-            'description': localize('less.builtin.saturation', 'returns the `saturation` channel of `@color` in the HSL space')
+            'description': l10n.t('returns the `saturation` channel of `@color` in the HSL space')
         },
         {
             'name': 'lightness',
             'example': 'lightness(@color);',
-            'description': localize('less.builtin.lightness', 'returns the `lightness` channel of `@color` in the HSL space')
+            'description': l10n.t('returns the `lightness` channel of `@color` in the HSL space')
         },
         {
             'name': 'hsvhue',
             'example': 'hsvhue(@color);',
-            'description': localize('less.builtin.hsvhue', 'returns the `hue` channel of `@color` in the HSV space')
+            'description': l10n.t('returns the `hue` channel of `@color` in the HSV space')
         },
         {
             'name': 'hsvsaturation',
             'example': 'hsvsaturation(@color);',
-            'description': localize('less.builtin.hsvsaturation', 'returns the `saturation` channel of `@color` in the HSV space')
+            'description': l10n.t('returns the `saturation` channel of `@color` in the HSV space')
         },
         {
             'name': 'hsvvalue',
             'example': 'hsvvalue(@color);',
-            'description': localize('less.builtin.hsvvalue', 'returns the `value` channel of `@color` in the HSV space')
+            'description': l10n.t('returns the `value` channel of `@color` in the HSV space')
         },
         {
             'name': 'red',
             'example': 'red(@color);',
-            'description': localize('less.builtin.red', 'returns the `red` channel of `@color`')
+            'description': l10n.t('returns the `red` channel of `@color`')
         },
         {
             'name': 'green',
             'example': 'green(@color);',
-            'description': localize('less.builtin.green', 'returns the `green` channel of `@color`')
+            'description': l10n.t('returns the `green` channel of `@color`')
         },
         {
             'name': 'blue',
             'example': 'blue(@color);',
-            'description': localize('less.builtin.blue', 'returns the `blue` channel of `@color`')
+            'description': l10n.t('returns the `blue` channel of `@color`')
         },
         {
             'name': 'alpha',
             'example': 'alpha(@color);',
-            'description': localize('less.builtin.alpha', 'returns the `alpha` channel of `@color`')
+            'description': l10n.t('returns the `alpha` channel of `@color`')
         },
         {
             'name': 'luma',
             'example': 'luma(@color);',
-            'description': localize('less.builtin.luma', 'returns the `luma` value (perceptual brightness) of `@color`')
+            'description': l10n.t('returns the `luma` value (perceptual brightness) of `@color`')
         },
         {
             'name': 'saturate',
             'example': 'saturate(@color, 10%);',
-            'description': localize('less.builtin.saturate', 'return `@color` 10% points more saturated')
+            'description': l10n.t('return `@color` 10% points more saturated')
         },
         {
             'name': 'desaturate',
             'example': 'desaturate(@color, 10%);',
-            'description': localize('less.builtin.desaturate', 'return `@color` 10% points less saturated')
+            'description': l10n.t('return `@color` 10% points less saturated')
         },
         {
             'name': 'lighten',
             'example': 'lighten(@color, 10%);',
-            'description': localize('less.builtin.lighten', 'return `@color` 10% points lighter')
+            'description': l10n.t('return `@color` 10% points lighter')
         },
         {
             'name': 'darken',
             'example': 'darken(@color, 10%);',
-            'description': localize('less.builtin.darken', 'return `@color` 10% points darker')
+            'description': l10n.t('return `@color` 10% points darker')
         },
         {
             'name': 'fadein',
             'example': 'fadein(@color, 10%);',
-            'description': localize('less.builtin.fadein', 'return `@color` 10% points less transparent')
+            'description': l10n.t('return `@color` 10% points less transparent')
         },
         {
             'name': 'fadeout',
             'example': 'fadeout(@color, 10%);',
-            'description': localize('less.builtin.fadeout', 'return `@color` 10% points more transparent')
+            'description': l10n.t('return `@color` 10% points more transparent')
         },
         {
             'name': 'fade',
             'example': 'fade(@color, 50%);',
-            'description': localize('less.builtin.fade', 'return `@color` with 50% transparency')
+            'description': l10n.t('return `@color` with 50% transparency')
         },
         {
             'name': 'spin',
             'example': 'spin(@color, 10);',
-            'description': localize('less.builtin.spin', 'return `@color` with a 10 degree larger in hue')
+            'description': l10n.t('return `@color` with a 10 degree larger in hue')
         },
         {
             'name': 'mix',
             'example': 'mix(@color1, @color2, [@weight: 50%]);',
-            'description': localize('less.builtin.mix', 'return a mix of `@color1` and `@color2`')
+            'description': l10n.t('return a mix of `@color1` and `@color2`')
         },
         {
             'name': 'greyscale',
             'example': 'greyscale(@color);',
-            'description': localize('less.builtin.greyscale', 'returns a grey, 100% desaturated color'),
+            'description': l10n.t('returns a grey, 100% desaturated color'),
         },
         {
             'name': 'contrast',
             'example': 'contrast(@color1, [@darkcolor: black], [@lightcolor: white], [@threshold: 43%]);',
-            'description': localize('less.builtin.contrast', 'return `@darkcolor` if `@color1 is> 43% luma` otherwise return `@lightcolor`, see notes')
+            'description': l10n.t('return `@darkcolor` if `@color1 is> 43% luma` otherwise return `@lightcolor`, see notes')
         },
         {
             'name': 'multiply',

package/lib/umd/services/lint.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "vscode-nls", "../languageFacts/facts", "../parser/cssNodes", "../utils/arrays", "./lintRules", "./lintUtil"], factory);
+        define(["require", "exports", "@vscode/l10n", "../languageFacts/facts", "../parser/cssNodes", "../utils/arrays", "./lintRules", "./lintUtil"], factory);
     }
 })(function (require, exports) {
     /*---------------------------------------------------------------------------------------------
@@ -14,13 +14,12 @@
     'use strict';
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.LintVisitor = void 0;
-    const nls = require("vscode-nls");
+    const l10n = require("@vscode/l10n");
     const languageFacts = require("../languageFacts/facts");
     const nodes = require("../parser/cssNodes");
     const arrays_1 = require("../utils/arrays");
     const lintRules_1 = require("./lintRules");
     const lintUtil_1 = require("./lintUtil");
-    const localize = nls.loadMessageBundle();
     class NodesByRootMap {
         constructor() {
             this.data = {};
@@ -38,6 +37,12 @@
         }
     }
     class LintVisitor {
+        static entries(node, document, settings, cssDataManager, entryFilter) {
+            const visitor = new LintVisitor(document, settings, cssDataManager);
+            node.acceptVisitor(visitor);
+            visitor.completeValidations();
+            return visitor.getEntries(entryFilter);
+        }
         constructor(document, settings, cssDataManager) {
             this.cssDataManager = cssDataManager;
             this.warnings = [];
@@ -57,12 +62,6 @@
                 });
             }
         }
-        static entries(node, document, settings, cssDataManager, entryFilter) {
-            const visitor = new LintVisitor(document, settings, cssDataManager);
-            node.acceptVisitor(visitor);
-            visitor.completeValidations();
-            return visitor.getEntries(entryFilter);
-        }
         isValidPropertyDeclaration(element) {
             const propertyName = element.fullPropertyName;
             return this.validProperties[propertyName];
@@ -120,10 +119,10 @@
                 const curr = expectedClone[i];
                 if (curr) {
                     if (result === null) {
-                        result = localize('namelist.single', "'{0}'", curr);
+                        result = l10n.t("'{0}'", curr);
                     }
                     else {
-                        result = localize('namelist.concatenated', "{0}, '{1}'", result, curr);
+                        result = l10n.t("{0}, '{1}'", result, curr);
                     }
                 }
             }
@@ -194,11 +193,11 @@
                 if (missingVendorSpecific || needsStandard) {
                     for (const node of this.keyframes.data[name].nodes) {
                         if (needsStandard) {
-                            const message = localize('keyframes.standardrule.missing', "Always define standard rule '@keyframes' when defining keyframes.");
+                            const message = l10n.t("Always define standard rule '@keyframes' when defining keyframes.");
                             this.addEntry(node, lintRules_1.Rules.IncludeStandardPropertyWhenUsingVendorPrefix, message);
                         }
                         if (missingVendorSpecific) {
-                            const message = localize('keyframes.vendorspecific.missing', "Always include all vendor specific rules: Missing: {0}", missingVendorSpecific);
+                            const message = l10n.t("Always include all vendor specific rules: Missing: {0}", missingVendorSpecific);
                             this.addEntry(node, lintRules_1.Rules.AllVendorPrefixes, message);
                         }
                     }
@@ -297,7 +296,7 @@
                     const node = elem[index].node;
                     const value = node.getValue();
                     if (value && !value.matches('none')) {
-                        this.addEntry(node, lintRules_1.Rules.PropertyIgnoredDueToDisplay, localize('rule.propertyIgnoredDueToDisplayInlineBlock', "inline-block is ignored due to the float. If 'float' has a value other than 'none', the box is floated and 'display' is treated as 'block'"));
+                        this.addEntry(node, lintRules_1.Rules.PropertyIgnoredDueToDisplay, l10n.t("inline-block is ignored due to the float. If 'float' has a value other than 'none', the box is floated and 'display' is treated as 'block'"));
                     }
                 }
             }
@@ -306,7 +305,7 @@
             if (displayElems.length > 0) {
                 const elem = this.fetch(propertyTable, 'vertical-align');
                 for (let index = 0; index < elem.length; index++) {
-                    this.addEntry(elem[index].node, lintRules_1.Rules.PropertyIgnoredDueToDisplay, localize('rule.propertyIgnoredDueToDisplayBlock', "Property is ignored due to the display. With 'display: block', vertical-align should not be used."));
+                    this.addEntry(elem[index].node, lintRules_1.Rules.PropertyIgnoredDueToDisplay, l10n.t("Property is ignored due to the display. With 'display: block', vertical-align should not be used."));
                 }
             }
             /////////////////////////////////////////////////////////////
@@ -369,7 +368,7 @@
                             // _property and *property might be contributed via custom data
                             if (!this.cssDataManager.isKnownProperty(fullName) && !this.cssDataManager.isKnownProperty(name)) {
                                 if (!this.validProperties[name]) {
-                                    this.addEntry(decl.getProperty(), lintRules_1.Rules.UnknownProperty, localize('property.unknownproperty.detailed', "Unknown property: '{0}'", decl.getFullPropertyName()));
+                                    this.addEntry(decl.getProperty(), lintRules_1.Rules.UnknownProperty, l10n.t("Unknown property: '{0}'", decl.getFullPropertyName()));
                                 }
                             }
                             propertiesBySuffix.add(name, name, null); // don't pass the node as we don't show errors on the standard
@@ -387,6 +386,23 @@
                         if (!needsStandard && actual.length === 1) {
                             continue; // only the non-vendor specific rule is used, that's fine, no warning
                         }
+                        /**
+                         * We should ignore missing standard properties, if there's an explicit contextual reference to a
+                         * vendor specific pseudo-element selector with the same vendor (prefix)
+                         *
+                         * (See https://github.com/microsoft/vscode/issues/164350)
+                         */
+                        const entriesThatNeedStandard = new Set(needsStandard ? entry.nodes : []);
+                        if (needsStandard) {
+                            const pseudoElements = this.getContextualVendorSpecificPseudoElements(node);
+                            for (const node of entry.nodes) {
+                                const propertyName = node.getName();
+                                const prefix = propertyName.substring(0, propertyName.length - suffix.length);
+                                if (pseudoElements.some(x => x.startsWith(prefix))) {
+                                    entriesThatNeedStandard.delete(node);
+                                }
+                            }
+                        }
                         const expected = [];
                         for (let i = 0, len = LintVisitor.prefixes.length; i < len; i++) {
                             const prefix = LintVisitor.prefixes[i];
@@ -397,12 +413,12 @@
                         const missingVendorSpecific = this.getMissingNames(expected, actual);
                         if (missingVendorSpecific || needsStandard) {
                             for (const node of entry.nodes) {
-                                if (needsStandard) {
-                                    const message = localize('property.standard.missing', "Also define the standard property '{0}' for compatibility", suffix);
+                                if (needsStandard && entriesThatNeedStandard.has(node)) {
+                                    const message = l10n.t("Also define the standard property '{0}' for compatibility", suffix);
                                     this.addEntry(node, lintRules_1.Rules.IncludeStandardPropertyWhenUsingVendorPrefix, message);
                                 }
                                 if (missingVendorSpecific) {
-                                    const message = localize('property.vendorspecific.missing', "Always include all vendor specific properties: Missing: {0}", missingVendorSpecific);
+                                    const message = l10n.t("Always include all vendor specific properties: Missing: {0}", missingVendorSpecific);
                                     this.addEntry(node, lintRules_1.Rules.AllVendorPrefixes, message);
                                 }
                             }
@@ -412,6 +428,36 @@
             }
             return true;
         }
+        /**
+         * Walks up the syntax tree (starting from given `node`) and captures vendor
+         * specific pseudo-element selectors.
+         * @returns An array of vendor specific pseudo-elements; or empty if none
+         * was found.
+         */
+        getContextualVendorSpecificPseudoElements(node) {
+            function walkDown(s, n) {
+                for (const child of n.getChildren()) {
+                    if (child.type === nodes.NodeType.PseudoSelector) {
+                        const pseudoElement = child.getChildren()[0]?.getText();
+                        if (pseudoElement) {
+                            s.add(pseudoElement);
+                        }
+                    }
+                    walkDown(s, child);
+                }
+            }
+            function walkUp(s, n) {
+                if (n.type === nodes.NodeType.Ruleset) {
+                    for (const selector of n.getSelectors().getChildren()) {
+                        walkDown(s, selector);
+                    }
+                }
+                return n.parent ? walkUp(s, n.parent) : undefined;
+            }
+            const result = new Set();
+            walkUp(result, node);
+            return Array.from(result);
+        }
         visitPrio(node) {
             /////////////////////////////////////////////////////////////
             //	Don't use !important

package/lib/umd/services/lintRules.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../parser/cssNodes", "vscode-nls"], factory);
+        define(["require", "exports", "../parser/cssNodes", "@vscode/l10n"], factory);
     }
 })(function (require, exports) {
     /*---------------------------------------------------------------------------------------------
@@ -15,8 +15,7 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.LintConfigurationSettings = exports.Settings = exports.Rules = exports.Setting = exports.Rule = void 0;
     const nodes = require("../parser/cssNodes");
-    const nls = require("vscode-nls");
-    const localize = nls.loadMessageBundle();
+    const l10n = require("@vscode/l10n");
     const Warning = nodes.Level.Warning;
     const Error = nodes.Level.Error;
     const Ignore = nodes.Level.Ignore;
@@ -39,28 +38,28 @@
     }
     exports.Setting = Setting;
     exports.Rules = {
-        AllVendorPrefixes: new Rule('compatibleVendorPrefixes', localize('rule.vendorprefixes.all', "When using a vendor-specific prefix make sure to also include all other vendor-specific properties"), Ignore),
-        IncludeStandardPropertyWhenUsingVendorPrefix: new Rule('vendorPrefix', localize('rule.standardvendorprefix.all', "When using a vendor-specific prefix also include the standard property"), Warning),
-        DuplicateDeclarations: new Rule('duplicateProperties', localize('rule.duplicateDeclarations', "Do not use duplicate style definitions"), Ignore),
-        EmptyRuleSet: new Rule('emptyRules', localize('rule.emptyRuleSets', "Do not use empty rulesets"), Warning),
-        ImportStatemement: new Rule('importStatement', localize('rule.importDirective', "Import statements do not load in parallel"), Ignore),
-        BewareOfBoxModelSize: new Rule('boxModel', localize('rule.bewareOfBoxModelSize', "Do not use width or height when using padding or border"), Ignore),
-        UniversalSelector: new Rule('universalSelector', localize('rule.universalSelector', "The universal selector (*) is known to be slow"), Ignore),
-        ZeroWithUnit: new Rule('zeroUnits', localize('rule.zeroWidthUnit', "No unit for zero needed"), Ignore),
-        RequiredPropertiesForFontFace: new Rule('fontFaceProperties', localize('rule.fontFaceProperties', "@font-face rule must define 'src' and 'font-family' properties"), Warning),
-        HexColorLength: new Rule('hexColorLength', localize('rule.hexColor', "Hex colors must consist of three, four, six or eight hex numbers"), Error),
-        ArgsInColorFunction: new Rule('argumentsInColorFunction', localize('rule.colorFunction', "Invalid number of parameters"), Error),
-        UnknownProperty: new Rule('unknownProperties', localize('rule.unknownProperty', "Unknown property."), Warning),
-        UnknownAtRules: new Rule('unknownAtRules', localize('rule.unknownAtRules', "Unknown at-rule."), Warning),
-        IEStarHack: new Rule('ieHack', localize('rule.ieHack', "IE hacks are only necessary when supporting IE7 and older"), Ignore),
-        UnknownVendorSpecificProperty: new Rule('unknownVendorSpecificProperties', localize('rule.unknownVendorSpecificProperty', "Unknown vendor specific property."), Ignore),
-        PropertyIgnoredDueToDisplay: new Rule('propertyIgnoredDueToDisplay', localize('rule.propertyIgnoredDueToDisplay', "Property is ignored due to the display."), Warning),
-        AvoidImportant: new Rule('important', localize('rule.avoidImportant', "Avoid using !important. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored."), Ignore),
-        AvoidFloat: new Rule('float', localize('rule.avoidFloat', "Avoid using 'float'. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes."), Ignore),
-        AvoidIdSelector: new Rule('idSelector', localize('rule.avoidIdSelector', "Selectors should not contain IDs because these rules are too tightly coupled with the HTML."), Ignore),
+        AllVendorPrefixes: new Rule('compatibleVendorPrefixes', l10n.t("When using a vendor-specific prefix make sure to also include all other vendor-specific properties"), Ignore),
+        IncludeStandardPropertyWhenUsingVendorPrefix: new Rule('vendorPrefix', l10n.t("When using a vendor-specific prefix also include the standard property"), Warning),
+        DuplicateDeclarations: new Rule('duplicateProperties', l10n.t("Do not use duplicate style definitions"), Ignore),
+        EmptyRuleSet: new Rule('emptyRules', l10n.t("Do not use empty rulesets"), Warning),
+        ImportStatemement: new Rule('importStatement', l10n.t("Import statements do not load in parallel"), Ignore),
+        BewareOfBoxModelSize: new Rule('boxModel', l10n.t("Do not use width or height when using padding or border"), Ignore),
+        UniversalSelector: new Rule('universalSelector', l10n.t("The universal selector (*) is known to be slow"), Ignore),
+        ZeroWithUnit: new Rule('zeroUnits', l10n.t("No unit for zero needed"), Ignore),
+        RequiredPropertiesForFontFace: new Rule('fontFaceProperties', l10n.t("@font-face rule must define 'src' and 'font-family' properties"), Warning),
+        HexColorLength: new Rule('hexColorLength', l10n.t("Hex colors must consist of three, four, six or eight hex numbers"), Error),
+        ArgsInColorFunction: new Rule('argumentsInColorFunction', l10n.t("Invalid number of parameters"), Error),
+        UnknownProperty: new Rule('unknownProperties', l10n.t("Unknown property."), Warning),
+        UnknownAtRules: new Rule('unknownAtRules', l10n.t("Unknown at-rule."), Warning),
+        IEStarHack: new Rule('ieHack', l10n.t("IE hacks are only necessary when supporting IE7 and older"), Ignore),
+        UnknownVendorSpecificProperty: new Rule('unknownVendorSpecificProperties', l10n.t("Unknown vendor specific property."), Ignore),
+        PropertyIgnoredDueToDisplay: new Rule('propertyIgnoredDueToDisplay', l10n.t("Property is ignored due to the display."), Warning),
+        AvoidImportant: new Rule('important', l10n.t("Avoid using !important. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored."), Ignore),
+        AvoidFloat: new Rule('float', l10n.t("Avoid using 'float'. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes."), Ignore),
+        AvoidIdSelector: new Rule('idSelector', l10n.t("Selectors should not contain IDs because these rules are too tightly coupled with the HTML."), Ignore),
     };
     exports.Settings = {
-        ValidProperties: new Setting('validProperties', localize('rule.validProperties', "A list of properties that are not validated against the `unknownProperties` rule."), [])
+        ValidProperties: new Setting('validProperties', l10n.t("A list of properties that are not validated against the `unknownProperties` rule."), [])
     };
     class LintConfigurationSettings {
         constructor(conf = {}) {