vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/umd/services/lint.js

@@ -14,19 +14,19 @@
     'use strict';
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.LintVisitor = void 0;
-    var nls = require("vscode-nls");
-    var languageFacts = require("../languageFacts/facts");
-    var nodes = require("../parser/cssNodes");
-    var arrays_1 = require("../utils/arrays");
-    var lintRules_1 = require("./lintRules");
-    var lintUtil_1 = require("./lintUtil");
-    var localize = nls.loadMessageBundle();
-    var NodesByRootMap = /** @class */ (function () {
-        function NodesByRootMap() {
+    const nls = require("vscode-nls");
+    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 = {};
         }
-        NodesByRootMap.prototype.add = function (root, name, node) {
-            var entry = this.data[root];
+        add(root, name, node) {
+            let entry = this.data[root];
             if (!entry) {
                 entry = { nodes: [], names: [] };
                 this.data[root] = entry;
@@ -35,94 +35,89 @@
             if (node) {
                 entry.nodes.push(node);
             }
-        };
-        return NodesByRootMap;
-    }());
-    var LintVisitor = /** @class */ (function () {
-        function LintVisitor(document, settings, cssDataManager) {
-            var _this = this;
+        }
+    }
+    class LintVisitor {
+        constructor(document, settings, cssDataManager) {
             this.cssDataManager = cssDataManager;
             this.warnings = [];
             this.settings = settings;
             this.documentText = document.getText();
             this.keyframes = new NodesByRootMap();
             this.validProperties = {};
-            var properties = settings.getSetting(lintRules_1.Settings.ValidProperties);
+            const properties = settings.getSetting(lintRules_1.Settings.ValidProperties);
             if (Array.isArray(properties)) {
-                properties.forEach(function (p) {
+                properties.forEach((p) => {
                     if (typeof p === 'string') {
-                        var name = p.trim().toLowerCase();
+                        const name = p.trim().toLowerCase();
                         if (name.length) {
-                            _this.validProperties[name] = true;
+                            this.validProperties[name] = true;
                         }
                     }
                 });
             }
         }
-        LintVisitor.entries = function (node, document, settings, cssDataManager, entryFilter) {
-            var visitor = new LintVisitor(document, settings, cssDataManager);
+        static entries(node, document, settings, cssDataManager, entryFilter) {
+            const visitor = new LintVisitor(document, settings, cssDataManager);
             node.acceptVisitor(visitor);
             visitor.completeValidations();
             return visitor.getEntries(entryFilter);
-        };
-        LintVisitor.prototype.isValidPropertyDeclaration = function (element) {
-            var propertyName = element.fullPropertyName;
+        }
+        isValidPropertyDeclaration(element) {
+            const propertyName = element.fullPropertyName;
             return this.validProperties[propertyName];
-        };
-        LintVisitor.prototype.fetch = function (input, s) {
-            var elements = [];
-            for (var _i = 0, input_1 = input; _i < input_1.length; _i++) {
-                var curr = input_1[_i];
+        }
+        fetch(input, s) {
+            const elements = [];
+            for (const curr of input) {
                 if (curr.fullPropertyName === s) {
                     elements.push(curr);
                 }
             }
             return elements;
-        };
-        LintVisitor.prototype.fetchWithValue = function (input, s, v) {
-            var elements = [];
-            for (var _i = 0, input_2 = input; _i < input_2.length; _i++) {
-                var inputElement = input_2[_i];
+        }
+        fetchWithValue(input, s, v) {
+            const elements = [];
+            for (const inputElement of input) {
                 if (inputElement.fullPropertyName === s) {
-                    var expression = inputElement.node.getValue();
+                    const expression = inputElement.node.getValue();
                     if (expression && this.findValueInExpression(expression, v)) {
                         elements.push(inputElement);
                     }
                 }
             }
             return elements;
-        };
-        LintVisitor.prototype.findValueInExpression = function (expression, v) {
-            var found = false;
-            expression.accept(function (node) {
+        }
+        findValueInExpression(expression, v) {
+            let found = false;
+            expression.accept(node => {
                 if (node.type === nodes.NodeType.Identifier && node.matches(v)) {
                     found = true;
                 }
                 return !found;
             });
             return found;
-        };
-        LintVisitor.prototype.getEntries = function (filter) {
-            if (filter === void 0) { filter = (nodes.Level.Warning | nodes.Level.Error); }
-            return this.warnings.filter(function (entry) {
+        }
+        getEntries(filter = (nodes.Level.Warning | nodes.Level.Error)) {
+            return this.warnings.filter(entry => {
                 return (entry.getLevel() & filter) !== 0;
             });
-        };
-        LintVisitor.prototype.addEntry = function (node, rule, details) {
-            var entry = new nodes.Marker(node, rule, this.settings.getRule(rule), details);
+        }
+        addEntry(node, rule, details) {
+            const entry = new nodes.Marker(node, rule, this.settings.getRule(rule), details);
             this.warnings.push(entry);
-        };
-        LintVisitor.prototype.getMissingNames = function (expected, actual) {
-            var expectedClone = expected.slice(0); // clone
-            for (var i = 0; i < actual.length; i++) {
-                var k = expectedClone.indexOf(actual[i]);
+        }
+        getMissingNames(expected, actual) {
+            const expectedClone = expected.slice(0); // clone
+            for (let i = 0; i < actual.length; i++) {
+                const k = expectedClone.indexOf(actual[i]);
                 if (k !== -1) {
                     expectedClone[k] = null;
                 }
             }
-            var result = null;
-            for (var i = 0; i < expectedClone.length; i++) {
-                var curr = expectedClone[i];
+            let result = null;
+            for (let i = 0; i < expectedClone.length; i++) {
+                const curr = expectedClone[i];
                 if (curr) {
                     if (result === null) {
                         result = localize('namelist.single', "'{0}'", curr);
@@ -133,8 +128,8 @@
                 }
             }
             return result;
-        };
-        LintVisitor.prototype.visitNode = function (node) {
+        }
+        visitNode(node) {
             switch (node.type) {
                 case nodes.NodeType.UnknownAtRule:
                     return this.visitUnknownAtRule(node);
@@ -160,87 +155,86 @@
                     return this.visitIdentifierSelector(node);
             }
             return true;
-        };
-        LintVisitor.prototype.completeValidations = function () {
+        }
+        completeValidations() {
             this.validateKeyframes();
-        };
-        LintVisitor.prototype.visitUnknownAtRule = function (node) {
-            var atRuleName = node.getChild(0);
+        }
+        visitUnknownAtRule(node) {
+            const atRuleName = node.getChild(0);
             if (!atRuleName) {
                 return false;
             }
-            var atDirective = this.cssDataManager.getAtDirective(atRuleName.getText());
+            const atDirective = this.cssDataManager.getAtDirective(atRuleName.getText());
             if (atDirective) {
                 return false;
             }
-            this.addEntry(atRuleName, lintRules_1.Rules.UnknownAtRules, "Unknown at rule ".concat(atRuleName.getText()));
+            this.addEntry(atRuleName, lintRules_1.Rules.UnknownAtRules, `Unknown at rule ${atRuleName.getText()}`);
             return true;
-        };
-        LintVisitor.prototype.visitKeyframe = function (node) {
-            var keyword = node.getKeyword();
+        }
+        visitKeyframe(node) {
+            const keyword = node.getKeyword();
             if (!keyword) {
                 return false;
             }
-            var text = keyword.getText();
+            const text = keyword.getText();
             this.keyframes.add(node.getName(), text, (text !== '@keyframes') ? keyword : null);
             return true;
-        };
-        LintVisitor.prototype.validateKeyframes = function () {
+        }
+        validateKeyframes() {
             // @keyframe and it's vendor specific alternatives
             // @keyframe should be included
-            var expected = ['@-webkit-keyframes', '@-moz-keyframes', '@-o-keyframes'];
-            for (var name in this.keyframes.data) {
-                var actual = this.keyframes.data[name].names;
-                var needsStandard = (actual.indexOf('@keyframes') === -1);
+            const expected = ['@-webkit-keyframes', '@-moz-keyframes', '@-o-keyframes'];
+            for (const name in this.keyframes.data) {
+                const actual = this.keyframes.data[name].names;
+                const needsStandard = (actual.indexOf('@keyframes') === -1);
                 if (!needsStandard && actual.length === 1) {
                     continue; // only the non-vendor specific keyword is used, that's fine, no warning
                 }
-                var missingVendorSpecific = this.getMissingNames(expected, actual);
+                const missingVendorSpecific = this.getMissingNames(expected, actual);
                 if (missingVendorSpecific || needsStandard) {
-                    for (var _i = 0, _a = this.keyframes.data[name].nodes; _i < _a.length; _i++) {
-                        var node = _a[_i];
+                    for (const node of this.keyframes.data[name].nodes) {
                         if (needsStandard) {
-                            var message = localize('keyframes.standardrule.missing', "Always define standard rule '@keyframes' when defining keyframes.");
+                            const message = localize('keyframes.standardrule.missing', "Always define standard rule '@keyframes' when defining keyframes.");
                             this.addEntry(node, lintRules_1.Rules.IncludeStandardPropertyWhenUsingVendorPrefix, message);
                         }
                         if (missingVendorSpecific) {
-                            var message = localize('keyframes.vendorspecific.missing', "Always include all vendor specific rules: Missing: {0}", missingVendorSpecific);
+                            const message = localize('keyframes.vendorspecific.missing', "Always include all vendor specific rules: Missing: {0}", missingVendorSpecific);
                             this.addEntry(node, lintRules_1.Rules.AllVendorPrefixes, message);
                         }
                     }
                 }
             }
             return true;
-        };
-        LintVisitor.prototype.visitSimpleSelector = function (node) {
+        }
+        visitSimpleSelector(node) {
             /////////////////////////////////////////////////////////////
             //	Lint - The universal selector (*) is known to be slow.
             /////////////////////////////////////////////////////////////
-            var firstChar = this.documentText.charAt(node.offset);
+            const firstChar = this.documentText.charAt(node.offset);
             if (node.length === 1 && firstChar === '*') {
                 this.addEntry(node, lintRules_1.Rules.UniversalSelector);
             }
             return true;
-        };
-        LintVisitor.prototype.visitIdentifierSelector = function (node) {
+        }
+        visitIdentifierSelector(node) {
             /////////////////////////////////////////////////////////////
             //	Lint - Avoid id selectors
             /////////////////////////////////////////////////////////////
             this.addEntry(node, lintRules_1.Rules.AvoidIdSelector);
             return true;
-        };
-        LintVisitor.prototype.visitImport = function (node) {
+        }
+        visitImport(node) {
             /////////////////////////////////////////////////////////////
             //	Lint - Import statements shouldn't be used, because they aren't offering parallel downloads.
             /////////////////////////////////////////////////////////////
             this.addEntry(node, lintRules_1.Rules.ImportStatemement);
             return true;
-        };
-        LintVisitor.prototype.visitRuleSet = function (node) {
+        }
+        visitRuleSet(node) {
             /////////////////////////////////////////////////////////////
             //	Lint - Don't use empty rulesets.
             /////////////////////////////////////////////////////////////
-            var declarations = node.getDeclarations();
+            const declarations = node.getDeclarations();
             if (!declarations) {
                 // syntax error
                 return false;
@@ -248,9 +242,8 @@
             if (!declarations.hasChildren()) {
                 this.addEntry(node.getSelectors(), lintRules_1.Rules.EmptyRuleSet);
             }
-            var propertyTable = [];
-            for (var _i = 0, _a = declarations.getChildren(); _i < _a.length; _i++) {
-                var element = _a[_i];
+            const propertyTable = [];
+            for (const element of declarations.getChildren()) {
                 if (element instanceof nodes.Declaration) {
                     propertyTable.push(new lintUtil_1.Element(element));
                 }
@@ -262,9 +255,9 @@
             // No error when box-sizing property is specified, as it assumes the user knows what he's doing.
             // see https://github.com/CSSLint/csslint/wiki/Beware-of-box-model-size
             /////////////////////////////////////////////////////////////
-            var boxModel = (0, lintUtil_1.default)(propertyTable);
+            const boxModel = (0, lintUtil_1.default)(propertyTable);
             if (boxModel.width) {
-                var properties = [];
+                let properties = [];
                 if (boxModel.right.value) {
                     properties = (0, arrays_1.union)(properties, boxModel.right.properties);
                 }
@@ -272,15 +265,14 @@
                     properties = (0, arrays_1.union)(properties, boxModel.left.properties);
                 }
                 if (properties.length !== 0) {
-                    for (var _b = 0, properties_1 = properties; _b < properties_1.length; _b++) {
-                        var item = properties_1[_b];
+                    for (const item of properties) {
                         this.addEntry(item.node, lintRules_1.Rules.BewareOfBoxModelSize);
                     }
                     this.addEntry(boxModel.width.node, lintRules_1.Rules.BewareOfBoxModelSize);
                 }
             }
             if (boxModel.height) {
-                var properties = [];
+                let properties = [];
                 if (boxModel.top.value) {
                     properties = (0, arrays_1.union)(properties, boxModel.top.properties);
                 }
@@ -288,8 +280,7 @@
                     properties = (0, arrays_1.union)(properties, boxModel.bottom.properties);
                 }
                 if (properties.length !== 0) {
-                    for (var _c = 0, properties_2 = properties; _c < properties_2.length; _c++) {
-                        var item = properties_2[_c];
+                    for (const item of properties) {
                         this.addEntry(item.node, lintRules_1.Rules.BewareOfBoxModelSize);
                     }
                     this.addEntry(boxModel.height.node, lintRules_1.Rules.BewareOfBoxModelSize);
@@ -299,31 +290,31 @@
             //	Properties ignored due to display
             /////////////////////////////////////////////////////////////
             // With 'display: inline-block', 'float' has no effect
-            var displayElems = this.fetchWithValue(propertyTable, 'display', 'inline-block');
+            let displayElems = this.fetchWithValue(propertyTable, 'display', 'inline-block');
             if (displayElems.length > 0) {
-                var elem = this.fetch(propertyTable, 'float');
-                for (var index = 0; index < elem.length; index++) {
-                    var node_1 = elem[index].node;
-                    var value = node_1.getValue();
+                const elem = this.fetch(propertyTable, 'float');
+                for (let index = 0; index < elem.length; index++) {
+                    const node = elem[index].node;
+                    const value = node.getValue();
                     if (value && !value.matches('none')) {
-                        this.addEntry(node_1, 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, 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'"));
                     }
                 }
             }
             // With 'display: block', 'vertical-align' has no effect
             displayElems = this.fetchWithValue(propertyTable, 'display', 'block');
             if (displayElems.length > 0) {
-                var elem = this.fetch(propertyTable, 'vertical-align');
-                for (var index = 0; index < elem.length; index++) {
+                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."));
                 }
             }
             /////////////////////////////////////////////////////////////
             //	Avoid 'float'
             /////////////////////////////////////////////////////////////
-            var elements = this.fetch(propertyTable, 'float');
-            for (var index = 0; index < elements.length; index++) {
-                var element = elements[index];
+            const elements = this.fetch(propertyTable, 'float');
+            for (let index = 0; index < elements.length; index++) {
+                const element = elements[index];
                 if (!this.isValidPropertyDeclaration(element)) {
                     this.addEntry(element.node, lintRules_1.Rules.AvoidFloat);
                 }
@@ -331,16 +322,16 @@
             /////////////////////////////////////////////////////////////
             //	Don't use duplicate declarations.
             /////////////////////////////////////////////////////////////
-            for (var i = 0; i < propertyTable.length; i++) {
-                var element = propertyTable[i];
+            for (let i = 0; i < propertyTable.length; i++) {
+                const element = propertyTable[i];
                 if (element.fullPropertyName !== 'background' && !this.validProperties[element.fullPropertyName]) {
-                    var value = element.node.getValue();
+                    const value = element.node.getValue();
                     if (value && this.documentText.charAt(value.offset) !== '-') {
-                        var elements_1 = this.fetch(propertyTable, element.fullPropertyName);
-                        if (elements_1.length > 1) {
-                            for (var k = 0; k < elements_1.length; k++) {
-                                var value_1 = elements_1[k].node.getValue();
-                                if (value_1 && this.documentText.charAt(value_1.offset) !== '-' && elements_1[k] !== element) {
+                        const elements = this.fetch(propertyTable, element.fullPropertyName);
+                        if (elements.length > 1) {
+                            for (let k = 0; k < elements.length; k++) {
+                                const value = elements[k].node.getValue();
+                                if (value && this.documentText.charAt(value.offset) !== '-' && elements[k] !== element) {
                                     this.addEntry(element.node, lintRules_1.Rules.DuplicateDeclarations);
                                 }
                             }
@@ -351,27 +342,26 @@
             /////////////////////////////////////////////////////////////
             //	Unknown propery & When using a vendor-prefixed gradient, make sure to use them all.
             /////////////////////////////////////////////////////////////
-            var isExportBlock = node.getSelectors().matches(":export");
+            const isExportBlock = node.getSelectors().matches(":export");
             if (!isExportBlock) {
-                var propertiesBySuffix = new NodesByRootMap();
-                var containsUnknowns = false;
-                for (var _d = 0, propertyTable_1 = propertyTable; _d < propertyTable_1.length; _d++) {
-                    var element = propertyTable_1[_d];
-                    var decl = element.node;
+                const propertiesBySuffix = new NodesByRootMap();
+                let containsUnknowns = false;
+                for (const element of propertyTable) {
+                    const decl = element.node;
                     if (this.isCSSDeclaration(decl)) {
-                        var name = element.fullPropertyName;
-                        var firstChar = name.charAt(0);
+                        let name = element.fullPropertyName;
+                        const firstChar = name.charAt(0);
                         if (firstChar === '-') {
                             if (name.charAt(1) !== '-') { // avoid css variables
                                 if (!this.cssDataManager.isKnownProperty(name) && !this.validProperties[name]) {
                                     this.addEntry(decl.getProperty(), lintRules_1.Rules.UnknownVendorSpecificProperty);
                                 }
-                                var nonPrefixedName = decl.getNonPrefixedPropertyName();
+                                const nonPrefixedName = decl.getNonPrefixedPropertyName();
                                 propertiesBySuffix.add(nonPrefixedName, name, decl.getProperty());
                             }
                         }
                         else {
-                            var fullName = name;
+                            const fullName = name;
                             if (firstChar === '*' || firstChar === '_') {
                                 this.addEntry(decl.getProperty(), lintRules_1.Rules.IEStarHack);
                                 name = name.substr(1);
@@ -390,31 +380,30 @@
                     }
                 }
                 if (!containsUnknowns) { // don't perform this test if there are
-                    for (var suffix in propertiesBySuffix.data) {
-                        var entry = propertiesBySuffix.data[suffix];
-                        var actual = entry.names;
-                        var needsStandard = this.cssDataManager.isStandardProperty(suffix) && (actual.indexOf(suffix) === -1);
+                    for (const suffix in propertiesBySuffix.data) {
+                        const entry = propertiesBySuffix.data[suffix];
+                        const actual = entry.names;
+                        const needsStandard = this.cssDataManager.isStandardProperty(suffix) && (actual.indexOf(suffix) === -1);
                         if (!needsStandard && actual.length === 1) {
                             continue; // only the non-vendor specific rule is used, that's fine, no warning
                         }
-                        var expected = [];
-                        for (var i = 0, len = LintVisitor.prefixes.length; i < len; i++) {
-                            var prefix = LintVisitor.prefixes[i];
+                        const expected = [];
+                        for (let i = 0, len = LintVisitor.prefixes.length; i < len; i++) {
+                            const prefix = LintVisitor.prefixes[i];
                             if (this.cssDataManager.isStandardProperty(prefix + suffix)) {
                                 expected.push(prefix + suffix);
                             }
                         }
-                        var missingVendorSpecific = this.getMissingNames(expected, actual);
+                        const missingVendorSpecific = this.getMissingNames(expected, actual);
                         if (missingVendorSpecific || needsStandard) {
-                            for (var _e = 0, _f = entry.nodes; _e < _f.length; _e++) {
-                                var node_2 = _f[_e];
+                            for (const node of entry.nodes) {
                                 if (needsStandard) {
-                                    var message = localize('property.standard.missing', "Also define the standard property '{0}' for compatibility", suffix);
-                                    this.addEntry(node_2, lintRules_1.Rules.IncludeStandardPropertyWhenUsingVendorPrefix, message);
+                                    const message = localize('property.standard.missing', "Also define the standard property '{0}' for compatibility", suffix);
+                                    this.addEntry(node, lintRules_1.Rules.IncludeStandardPropertyWhenUsingVendorPrefix, message);
                                 }
                                 if (missingVendorSpecific) {
-                                    var message = localize('property.vendorspecific.missing', "Always include all vendor specific properties: Missing: {0}", missingVendorSpecific);
-                                    this.addEntry(node_2, lintRules_1.Rules.AllVendorPrefixes, message);
+                                    const message = localize('property.vendorspecific.missing', "Always include all vendor specific properties: Missing: {0}", missingVendorSpecific);
+                                    this.addEntry(node, lintRules_1.Rules.AllVendorPrefixes, message);
                                 }
                             }
                         }
@@ -422,27 +411,27 @@
                 }
             }
             return true;
-        };
-        LintVisitor.prototype.visitPrio = function (node) {
+        }
+        visitPrio(node) {
             /////////////////////////////////////////////////////////////
             //	Don't use !important
             /////////////////////////////////////////////////////////////
             this.addEntry(node, lintRules_1.Rules.AvoidImportant);
             return true;
-        };
-        LintVisitor.prototype.visitNumericValue = function (node) {
+        }
+        visitNumericValue(node) {
             /////////////////////////////////////////////////////////////
             //	0 has no following unit
             /////////////////////////////////////////////////////////////
-            var funcDecl = node.findParent(nodes.NodeType.Function);
+            const funcDecl = node.findParent(nodes.NodeType.Function);
             if (funcDecl && funcDecl.getName() === 'calc') {
                 return true;
             }
-            var decl = node.findParent(nodes.NodeType.Declaration);
+            const decl = node.findParent(nodes.NodeType.Declaration);
             if (decl) {
-                var declValue = decl.getValue();
+                const declValue = decl.getValue();
                 if (declValue) {
-                    var value = node.getValue();
+                    const value = node.getValue();
                     if (!value.unit || languageFacts.units.length.indexOf(value.unit.toLowerCase()) === -1) {
                         return true;
                     }
@@ -452,19 +441,18 @@
                 }
             }
             return true;
-        };
-        LintVisitor.prototype.visitFontFace = function (node) {
-            var declarations = node.getDeclarations();
+        }
+        visitFontFace(node) {
+            const declarations = node.getDeclarations();
             if (!declarations) {
                 // syntax error
                 return false;
             }
-            var definesSrc = false, definesFontFamily = false;
-            var containsUnknowns = false;
-            for (var _i = 0, _a = declarations.getChildren(); _i < _a.length; _i++) {
-                var node_3 = _a[_i];
-                if (this.isCSSDeclaration(node_3)) {
-                    var name = node_3.getProperty().getName().toLowerCase();
+            let definesSrc = false, definesFontFamily = false;
+            let containsUnknowns = false;
+            for (const node of declarations.getChildren()) {
+                if (this.isCSSDeclaration(node)) {
+                    const name = node.getProperty().getName().toLowerCase();
                     if (name === 'src') {
                         definesSrc = true;
                     }
@@ -480,36 +468,36 @@
                 this.addEntry(node, lintRules_1.Rules.RequiredPropertiesForFontFace);
             }
             return true;
-        };
-        LintVisitor.prototype.isCSSDeclaration = function (node) {
+        }
+        isCSSDeclaration(node) {
             if (node instanceof nodes.Declaration) {
                 if (!node.getValue()) {
                     return false;
                 }
-                var property = node.getProperty();
+                const property = node.getProperty();
                 if (!property) {
                     return false;
                 }
-                var identifier = property.getIdentifier();
+                const identifier = property.getIdentifier();
                 if (!identifier || identifier.containsInterpolation()) {
                     return false;
                 }
                 return true;
             }
             return false;
-        };
-        LintVisitor.prototype.visitHexColorValue = function (node) {
+        }
+        visitHexColorValue(node) {
             // Rule: #eeff0011 or #eeff00 or #ef01 or #ef0
-            var length = node.length;
+            const length = node.length;
             if (length !== 9 && length !== 7 && length !== 5 && length !== 4) {
                 this.addEntry(node, lintRules_1.Rules.HexColorLength);
             }
             return false;
-        };
-        LintVisitor.prototype.visitFunction = function (node) {
-            var fnName = node.getName().toLowerCase();
-            var expectedAttrCount = -1;
-            var actualAttrCount = 0;
+        }
+        visitFunction(node) {
+            const fnName = node.getName().toLowerCase();
+            let expectedAttrCount = -1;
+            let actualAttrCount = 0;
             switch (fnName) {
                 case 'rgb(':
                 case 'hsl(':
@@ -521,7 +509,7 @@
                     break;
             }
             if (expectedAttrCount !== -1) {
-                node.getArguments().accept(function (n) {
+                node.getArguments().accept(n => {
                     if (n instanceof nodes.BinaryExpression) {
                         actualAttrCount += 1;
                         return false;
@@ -533,12 +521,11 @@
                 }
             }
             return true;
-        };
-        LintVisitor.prefixes = [
-            '-ms-', '-moz-', '-o-', '-webkit-', // Quite common
-            //		'-xv-', '-atsc-', '-wap-', '-khtml-', 'mso-', 'prince-', '-ah-', '-hp-', '-ro-', '-rim-', '-tc-' // Quite un-common
-        ];
-        return LintVisitor;
-    }());
+        }
+    }
     exports.LintVisitor = LintVisitor;
+    LintVisitor.prefixes = [
+        '-ms-', '-moz-', '-o-', '-webkit-', // Quite common
+        //		'-xv-', '-atsc-', '-wap-', '-khtml-', 'mso-', 'prince-', '-ah-', '-hp-', '-ro-', '-rim-', '-tc-' // Quite un-common
+    ];
 });