vscode-css-languageservice 6.1.1 → 6.2.2

package/lib/esm/services/lessCompletion.js

@@ -5,8 +5,7 @@
 'use strict';
 import { CSSCompletion } from './cssCompletion';
 import { CompletionItemKind, InsertTextFormat, TextEdit } from '../cssLanguageTypes';
-import * as nls from 'vscode-nls';
-const localize = nls.loadMessageBundle();
+import * as l10n from '@vscode/l10n';
 export class LESSCompletion extends CSSCompletion {
     constructor(lsOptions, cssDataManager) {
         super('@', lsOptions, cssDataManager);
@@ -50,156 +49,156 @@ LESSCompletion.builtInProposals = [
     {
         '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);'
     }
 ];
@@ -207,137 +206,137 @@ LESSCompletion.colorProposals = [
     {
         '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/esm/services/lint.js

@@ -3,13 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-import * as nls from 'vscode-nls';
+import * as l10n from '@vscode/l10n';
 import * as languageFacts from '../languageFacts/facts';
 import * as nodes from '../parser/cssNodes';
 import { union } from '../utils/arrays';
 import { Rules, Settings } from './lintRules';
 import calculateBoxModel, { Element } from './lintUtil';
-const localize = nls.loadMessageBundle();
 class NodesByRootMap {
     constructor() {
         this.data = {};
@@ -27,6 +26,12 @@ class NodesByRootMap {
     }
 }
 export 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 = [];
@@ -46,12 +51,6 @@ export 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);
-    }
     isValidPropertyDeclaration(element) {
         const propertyName = element.fullPropertyName;
         return this.validProperties[propertyName];
@@ -109,10 +108,10 @@ export class LintVisitor {
             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);
                 }
             }
         }
@@ -183,11 +182,11 @@ export class LintVisitor {
             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, 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, Rules.AllVendorPrefixes, message);
                     }
                 }
@@ -286,7 +285,7 @@ export class LintVisitor {
                 const node = elem[index].node;
                 const value = node.getValue();
                 if (value && !value.matches('none')) {
-                    this.addEntry(node, 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, 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'"));
                 }
             }
         }
@@ -295,7 +294,7 @@ export class LintVisitor {
         if (displayElems.length > 0) {
             const elem = this.fetch(propertyTable, 'vertical-align');
             for (let index = 0; index < elem.length; index++) {
-                this.addEntry(elem[index].node, 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, Rules.PropertyIgnoredDueToDisplay, l10n.t("Property is ignored due to the display. With 'display: block', vertical-align should not be used."));
             }
         }
         /////////////////////////////////////////////////////////////
@@ -358,7 +357,7 @@ export class LintVisitor {
                         // _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(), Rules.UnknownProperty, localize('property.unknownproperty.detailed', "Unknown property: '{0}'", decl.getFullPropertyName()));
+                                this.addEntry(decl.getProperty(), 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
@@ -376,6 +375,23 @@ export class LintVisitor {
                     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];
@@ -386,12 +402,12 @@ export class LintVisitor {
                     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, 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, Rules.AllVendorPrefixes, message);
                             }
                         }
@@ -401,6 +417,36 @@ export class LintVisitor {
         }
         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/esm/services/lintRules.js

@@ -4,8 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 import * as nodes from '../parser/cssNodes';
-import * as nls from 'vscode-nls';
-const localize = nls.loadMessageBundle();
+import * as l10n from '@vscode/l10n';
 const Warning = nodes.Level.Warning;
 const Error = nodes.Level.Error;
 const Ignore = nodes.Level.Ignore;
@@ -26,28 +25,28 @@ export class Setting {
     }
 }
 export const 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),
 };
 export const 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."), [])
 };
 export class LintConfigurationSettings {
     constructor(conf = {}) {