vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/esm/languageFacts/builtinData.js

@@ -3,14 +3,14 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-export var positionKeywords = {
+export const positionKeywords = {
     'bottom': 'Computes to ‘100%’ for the vertical position if one or two values are given, otherwise specifies the bottom edge as the origin for the next offset.',
     'center': 'Computes to ‘50%’ (‘left 50%’) for the horizontal position if the horizontal position is not otherwise specified, or ‘50%’ (‘top 50%’) for the vertical position if it is.',
     'left': 'Computes to ‘0%’ for the horizontal position if one or two values are given, otherwise specifies the left edge as the origin for the next offset.',
     'right': 'Computes to ‘100%’ for the horizontal position if one or two values are given, otherwise specifies the right edge as the origin for the next offset.',
     'top': 'Computes to ‘0%’ for the vertical position if one or two values are given, otherwise specifies the top edge as the origin for the next offset.'
 };
-export var repeatStyleKeywords = {
+export const repeatStyleKeywords = {
     'no-repeat': 'Placed once and not repeated in this direction.',
     'repeat': 'Repeated in this direction as often as needed to cover the background painting area.',
     'repeat-x': 'Computes to ‘repeat no-repeat’.',
@@ -18,7 +18,7 @@ export var repeatStyleKeywords = {
     'round': 'Repeated as often as will fit within the background positioning area. If it doesn’t fit a whole number of times, it is rescaled so that it does.',
     'space': 'Repeated as often as will fit within the background positioning area without being clipped and then the images are spaced out to fill the area.'
 };
-export var lineStyleKeywords = {
+export const lineStyleKeywords = {
     'dashed': 'A series of square-ended dashes.',
     'dotted': 'A series of round dots.',
     'double': 'Two parallel solid lines with some space between them.',
@@ -30,28 +30,28 @@ export var lineStyleKeywords = {
     'ridge': 'Looks as if it were coming out of the canvas.',
     'solid': 'A single line segment.'
 };
-export var lineWidthKeywords = ['medium', 'thick', 'thin'];
-export var boxKeywords = {
+export const lineWidthKeywords = ['medium', 'thick', 'thin'];
+export const boxKeywords = {
     'border-box': 'The background is painted within (clipped to) the border box.',
     'content-box': 'The background is painted within (clipped to) the content box.',
     'padding-box': 'The background is painted within (clipped to) the padding box.'
 };
-export var geometryBoxKeywords = {
+export const geometryBoxKeywords = {
     'margin-box': 'Uses the margin box as reference box.',
     'fill-box': 'Uses the object bounding box as reference box.',
     'stroke-box': 'Uses the stroke bounding box as reference box.',
     'view-box': 'Uses the nearest SVG viewport as reference box.'
 };
-export var cssWideKeywords = {
+export const cssWideKeywords = {
     'initial': 'Represents the value specified as the property’s initial value.',
     'inherit': 'Represents the computed value of the property on the element’s parent.',
     'unset': 'Acts as either `inherit` or `initial`, depending on whether the property is inherited or not.'
 };
-export var cssWideFunctions = {
+export const cssWideFunctions = {
     'var()': 'Evaluates the value of a custom variable.',
     'calc()': 'Evaluates an mathematical expression. The following operators can be used: + - * /.'
 };
-export var imageFunctions = {
+export const imageFunctions = {
     'url()': 'Reference an image file by URL',
     'image()': 'Provide image fallbacks and annotations.',
     '-webkit-image-set()': 'Provide multiple resolutions. Remember to use unprefixed image-set() in addition.',
@@ -75,7 +75,7 @@ export var imageFunctions = {
     '-moz-repeating-radial-gradient()': 'Repeating radial gradient. Remember to use unprefixed version in addition.',
     'repeating-radial-gradient()': 'Same as radial-gradient, except the color-stops are repeated infinitely in both directions, with their positions shifted by multiples of the difference between the last specified color-stop’s position and the first specified color-stop’s position.'
 };
-export var transitionTimingFunctions = {
+export const transitionTimingFunctions = {
     'ease': 'Equivalent to cubic-bezier(0.25, 0.1, 0.25, 1.0).',
     'ease-in': 'Equivalent to cubic-bezier(0.42, 0, 1.0, 1.0).',
     'ease-in-out': 'Equivalent to cubic-bezier(0.42, 0, 0.58, 1.0).',
@@ -110,13 +110,13 @@ export var transitionTimingFunctions = {
     'cubic-bezier(0.86, 0, 0.07, 1)': 'Ease-in-out Quintic. Based on power of five.',
     'cubic-bezier(0.23, 1, 0.320, 1)': 'Ease-out Quintic. Based on power of five.'
 };
-export var basicShapeFunctions = {
+export const basicShapeFunctions = {
     'circle()': 'Defines a circle.',
     'ellipse()': 'Defines an ellipse.',
     'inset()': 'Defines an inset rectangle.',
     'polygon()': 'Defines a polygon.'
 };
-export var units = {
+export const units = {
     'length': ['em', 'rem', 'ex', 'px', 'cm', 'mm', 'in', 'pt', 'pc', 'ch', 'vw', 'vh', 'vmin', 'vmax'],
     'angle': ['deg', 'rad', 'grad', 'turn'],
     'time': ['ms', 's'],
@@ -124,18 +124,18 @@ export var units = {
     'resolution': ['dpi', 'dpcm', 'dppx'],
     'percentage': ['%', 'fr']
 };
-export var html5Tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption',
+export const html5Tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption',
     'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer',
     'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link',
     'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q',
     'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td',
     'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'const', 'video', 'wbr'];
-export var svgElements = ['circle', 'clipPath', 'cursor', 'defs', 'desc', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting',
+export const svgElements = ['circle', 'clipPath', 'cursor', 'defs', 'desc', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting',
     'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology',
     'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence', 'filter', 'foreignObject', 'g', 'hatch', 'hatchpath', 'image', 'line', 'linearGradient',
     'marker', 'mask', 'mesh', 'meshpatch', 'meshrow', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'set', 'solidcolor', 'stop', 'svg', 'switch',
     'symbol', 'text', 'textPath', 'tspan', 'use', 'view'];
-export var pageBoxDirectives = [
+export const pageBoxDirectives = [
     '@bottom-center', '@bottom-left', '@bottom-left-corner', '@bottom-right', '@bottom-right-corner',
     '@left-bottom', '@left-middle', '@left-top', '@right-bottom', '@right-middle', '@right-top',
     '@top-center', '@top-left', '@top-left-corner', '@top-right', '@top-right-corner'

package/lib/esm/languageFacts/colors.js

@@ -4,15 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 import * as nodes from '../parser/cssNodes';
 import * as nls from 'vscode-nls';
-var localize = nls.loadMessageBundle();
-export var colorFunctions = [
+const localize = nls.loadMessageBundle();
+export const colorFunctions = [
     { func: 'rgb($red, $green, $blue)', desc: localize('css.builtin.rgb', 'Creates a Color from red, green, and blue values.') },
     { func: 'rgba($red, $green, $blue, $alpha)', desc: localize('css.builtin.rgba', 'Creates a Color from red, green, blue, and alpha values.') },
     { func: 'hsl($hue, $saturation, $lightness)', desc: localize('css.builtin.hsl', 'Creates a Color from hue, saturation, and lightness values.') },
     { func: 'hsla($hue, $saturation, $lightness, $alpha)', desc: localize('css.builtin.hsla', 'Creates a Color from hue, saturation, lightness, and alpha values.') },
     { func: 'hwb($hue $white $black)', desc: localize('css.builtin.hwb', 'Creates a Color from hue, white and black.') }
 ];
-export var colors = {
+export const colors = {
     aliceblue: '#f0f8ff',
     antiquewhite: '#faebd7',
     aqua: '#00ffff',
@@ -162,18 +162,18 @@ export var colors = {
     yellow: '#ffff00',
     yellowgreen: '#9acd32'
 };
-export var colorKeywords = {
+export const colorKeywords = {
     'currentColor': 'The value of the \'color\' property. The computed value of the \'currentColor\' keyword is the computed value of the \'color\' property. If the \'currentColor\' keyword is set on the \'color\' property itself, it is treated as \'color:inherit\' at parse time.',
     'transparent': 'Fully transparent. This keyword can be considered a shorthand for rgba(0,0,0,0) which is its computed value.',
 };
 function getNumericValue(node, factor) {
-    var val = node.getText();
-    var m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(%?)$/);
+    const val = node.getText();
+    const m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(%?)$/);
     if (m) {
         if (m[2]) {
             factor = 100.0;
         }
-        var result = parseFloat(m[1]) / factor;
+        const result = parseFloat(m[1]) / factor;
         if (result >= 0 && result <= 1) {
             return result;
         }
@@ -181,8 +181,8 @@ function getNumericValue(node, factor) {
     throw new Error();
 }
 function getAngle(node) {
-    var val = node.getText();
-    var m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(deg|rad|grad|turn)?$/);
+    const val = node.getText();
+    const m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(deg|rad|grad|turn)?$/);
     if (m) {
         switch (m[2]) {
             case 'deg':
@@ -202,7 +202,7 @@ function getAngle(node) {
     throw new Error();
 }
 export function isColorConstructor(node) {
-    var name = node.getName();
+    const name = node.getName();
     if (!name) {
         return false;
     }
@@ -224,7 +224,7 @@ export function isColorValue(node) {
         if (node.parent && node.parent.type !== nodes.NodeType.Term) {
             return false;
         }
-        var candidateColor = node.getText().toLowerCase();
+        const candidateColor = node.getText().toLowerCase();
         if (candidateColor === 'none') {
             return false;
         }
@@ -234,12 +234,12 @@ export function isColorValue(node) {
     }
     return false;
 }
-var Digit0 = 48;
-var Digit9 = 57;
-var A = 65;
-var F = 70;
-var a = 97;
-var f = 102;
+const Digit0 = 48;
+const Digit9 = 57;
+const A = 65;
+const F = 70;
+const a = 97;
+const f = 102;
 export function hexDigit(charCode) {
     if (charCode < Digit0) {
         return 0;
@@ -291,23 +291,21 @@ export function colorFromHex(text) {
     }
     return null;
 }
-export function colorFrom256RGB(red, green, blue, alpha) {
-    if (alpha === void 0) { alpha = 1.0; }
+export function colorFrom256RGB(red, green, blue, alpha = 1.0) {
     return {
         red: red / 255.0,
         green: green / 255.0,
         blue: blue / 255.0,
-        alpha: alpha
+        alpha
     };
 }
-export function colorFromHSL(hue, sat, light, alpha) {
-    if (alpha === void 0) { alpha = 1.0; }
+export function colorFromHSL(hue, sat, light, alpha = 1.0) {
     hue = hue / 60.0;
     if (sat === 0) {
-        return { red: light, green: light, blue: light, alpha: alpha };
+        return { red: light, green: light, blue: light, alpha };
     }
     else {
-        var hueToRgb = function (t1, t2, hue) {
+        const hueToRgb = (t1, t2, hue) => {
             while (hue < 0) {
                 hue += 6;
             }
@@ -325,22 +323,22 @@ export function colorFromHSL(hue, sat, light, alpha) {
             }
             return t1;
         };
-        var t2 = light <= 0.5 ? (light * (sat + 1)) : (light + sat - (light * sat));
-        var t1 = light * 2 - t2;
-        return { red: hueToRgb(t1, t2, hue + 2), green: hueToRgb(t1, t2, hue), blue: hueToRgb(t1, t2, hue - 2), alpha: alpha };
+        const t2 = light <= 0.5 ? (light * (sat + 1)) : (light + sat - (light * sat));
+        const t1 = light * 2 - t2;
+        return { red: hueToRgb(t1, t2, hue + 2), green: hueToRgb(t1, t2, hue), blue: hueToRgb(t1, t2, hue - 2), alpha };
     }
 }
 export function hslFromColor(rgba) {
-    var r = rgba.red;
-    var g = rgba.green;
-    var b = rgba.blue;
-    var a = rgba.alpha;
-    var max = Math.max(r, g, b);
-    var min = Math.min(r, g, b);
-    var h = 0;
-    var s = 0;
-    var l = (min + max) / 2;
-    var chroma = max - min;
+    const r = rgba.red;
+    const g = rgba.green;
+    const b = rgba.blue;
+    const a = rgba.alpha;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let h = 0;
+    let s = 0;
+    const l = (min + max) / 2;
+    const chroma = max - min;
     if (chroma > 0) {
         s = Math.min((l <= 0.5 ? chroma / (2 * l) : chroma / (2 - (2 * l))), 1);
         switch (max) {
@@ -357,35 +355,34 @@ export function hslFromColor(rgba) {
         h *= 60;
         h = Math.round(h);
     }
-    return { h: h, s: s, l: l, a: a };
+    return { h, s, l, a };
 }
-export function colorFromHWB(hue, white, black, alpha) {
-    if (alpha === void 0) { alpha = 1.0; }
+export function colorFromHWB(hue, white, black, alpha = 1.0) {
     if (white + black >= 1) {
-        var gray = white / (white + black);
-        return { red: gray, green: gray, blue: gray, alpha: alpha };
+        const gray = white / (white + black);
+        return { red: gray, green: gray, blue: gray, alpha };
     }
-    var rgb = colorFromHSL(hue, 1, 0.5, alpha);
-    var red = rgb.red;
+    const rgb = colorFromHSL(hue, 1, 0.5, alpha);
+    let red = rgb.red;
     red *= (1 - white - black);
     red += white;
-    var green = rgb.green;
+    let green = rgb.green;
     green *= (1 - white - black);
     green += white;
-    var blue = rgb.blue;
+    let blue = rgb.blue;
     blue *= (1 - white - black);
     blue += white;
     return {
         red: red,
         green: green,
         blue: blue,
-        alpha: alpha
+        alpha
     };
 }
 export function hwbFromColor(rgba) {
-    var hsl = hslFromColor(rgba);
-    var white = Math.min(rgba.red, rgba.green, rgba.blue);
-    var black = 1 - Math.max(rgba.red, rgba.green, rgba.blue);
+    const hsl = hslFromColor(rgba);
+    const white = Math.min(rgba.red, rgba.green, rgba.blue);
+    const black = 1 - Math.max(rgba.red, rgba.green, rgba.blue);
     return {
         h: hsl.h,
         w: white,
@@ -395,21 +392,21 @@ export function hwbFromColor(rgba) {
 }
 export function getColorValue(node) {
     if (node.type === nodes.NodeType.HexColorValue) {
-        var text = node.getText();
+        const text = node.getText();
         return colorFromHex(text);
     }
     else if (node.type === nodes.NodeType.Function) {
-        var functionNode = node;
-        var name = functionNode.getName();
-        var colorValues = functionNode.getArguments().getChildren();
+        const functionNode = node;
+        const name = functionNode.getName();
+        let colorValues = functionNode.getArguments().getChildren();
         if (colorValues.length === 1) {
-            var functionArg = colorValues[0].getChildren();
+            const functionArg = colorValues[0].getChildren();
             if (functionArg.length === 1 && functionArg[0].type === nodes.NodeType.Expression) {
                 colorValues = functionArg[0].getChildren();
                 if (colorValues.length === 3) {
-                    var lastValue = colorValues[2];
+                    const lastValue = colorValues[2];
                     if (lastValue instanceof nodes.BinaryExpression) {
-                        var left = lastValue.getLeft(), right = lastValue.getRight(), operator = lastValue.getOperator();
+                        const left = lastValue.getLeft(), right = lastValue.getRight(), operator = lastValue.getOperator();
                         if (left && right && operator && operator.matches('/')) {
                             colorValues = [colorValues[0], colorValues[1], left, right];
                         }
@@ -421,25 +418,25 @@ export function getColorValue(node) {
             return null;
         }
         try {
-            var alpha = colorValues.length === 4 ? getNumericValue(colorValues[3], 1) : 1;
+            const alpha = colorValues.length === 4 ? getNumericValue(colorValues[3], 1) : 1;
             if (name === 'rgb' || name === 'rgba') {
                 return {
                     red: getNumericValue(colorValues[0], 255.0),
                     green: getNumericValue(colorValues[1], 255.0),
                     blue: getNumericValue(colorValues[2], 255.0),
-                    alpha: alpha
+                    alpha
                 };
             }
             else if (name === 'hsl' || name === 'hsla') {
-                var h = getAngle(colorValues[0]);
-                var s = getNumericValue(colorValues[1], 100.0);
-                var l = getNumericValue(colorValues[2], 100.0);
+                const h = getAngle(colorValues[0]);
+                const s = getNumericValue(colorValues[1], 100.0);
+                const l = getNumericValue(colorValues[2], 100.0);
                 return colorFromHSL(h, s, l, alpha);
             }
             else if (name === 'hwb') {
-                var h = getAngle(colorValues[0]);
-                var w = getNumericValue(colorValues[1], 100.0);
-                var b = getNumericValue(colorValues[2], 100.0);
+                const h = getAngle(colorValues[0]);
+                const w = getNumericValue(colorValues[1], 100.0);
+                const b = getNumericValue(colorValues[2], 100.0);
                 return colorFromHWB(h, w, b, alpha);
             }
         }
@@ -452,18 +449,18 @@ export function getColorValue(node) {
         if (node.parent && node.parent.type !== nodes.NodeType.Term) {
             return null;
         }
-        var term = node.parent;
+        const term = node.parent;
         if (term && term.parent && term.parent.type === nodes.NodeType.BinaryExpression) {
-            var expression = term.parent;
+            const expression = term.parent;
             if (expression.parent && expression.parent.type === nodes.NodeType.ListEntry && expression.parent.key === expression) {
                 return null;
             }
         }
-        var candidateColor = node.getText().toLowerCase();
+        const candidateColor = node.getText().toLowerCase();
         if (candidateColor === 'none') {
             return null;
         }
-        var colorHex = colors[candidateColor];
+        const colorHex = colors[candidateColor];
         if (colorHex) {
             return colorFromHex(colorHex);
         }

package/lib/esm/languageFacts/dataManager.js

@@ -6,8 +6,8 @@
 import * as objects from '../utils/objects';
 import { cssData } from '../data/webCustomData';
 import { CSSDataProvider } from './dataProvider';
-var CSSDataManager = /** @class */ (function () {
-    function CSSDataManager(options) {
+export class CSSDataManager {
+    constructor(options) {
         this.dataProviders = [];
         this._propertySet = {};
         this._atDirectiveSet = {};
@@ -17,45 +17,43 @@ var CSSDataManager = /** @class */ (function () {
         this._atDirectives = [];
         this._pseudoClasses = [];
         this._pseudoElements = [];
-        this.setDataProviders((options === null || options === void 0 ? void 0 : options.useDefaultDataProvider) !== false, (options === null || options === void 0 ? void 0 : options.customDataProviders) || []);
+        this.setDataProviders(options?.useDefaultDataProvider !== false, options?.customDataProviders || []);
     }
-    CSSDataManager.prototype.setDataProviders = function (builtIn, providers) {
-        var _a;
+    setDataProviders(builtIn, providers) {
         this.dataProviders = [];
         if (builtIn) {
             this.dataProviders.push(new CSSDataProvider(cssData));
         }
-        (_a = this.dataProviders).push.apply(_a, providers);
+        this.dataProviders.push(...providers);
         this.collectData();
-    };
+    }
     /**
      * Collect all data  & handle duplicates
      */
-    CSSDataManager.prototype.collectData = function () {
-        var _this = this;
+    collectData() {
         this._propertySet = {};
         this._atDirectiveSet = {};
         this._pseudoClassSet = {};
         this._pseudoElementSet = {};
-        this.dataProviders.forEach(function (provider) {
-            provider.provideProperties().forEach(function (p) {
-                if (!_this._propertySet[p.name]) {
-                    _this._propertySet[p.name] = p;
+        this.dataProviders.forEach(provider => {
+            provider.provideProperties().forEach(p => {
+                if (!this._propertySet[p.name]) {
+                    this._propertySet[p.name] = p;
                 }
             });
-            provider.provideAtDirectives().forEach(function (p) {
-                if (!_this._atDirectiveSet[p.name]) {
-                    _this._atDirectiveSet[p.name] = p;
+            provider.provideAtDirectives().forEach(p => {
+                if (!this._atDirectiveSet[p.name]) {
+                    this._atDirectiveSet[p.name] = p;
                 }
             });
-            provider.providePseudoClasses().forEach(function (p) {
-                if (!_this._pseudoClassSet[p.name]) {
-                    _this._pseudoClassSet[p.name] = p;
+            provider.providePseudoClasses().forEach(p => {
+                if (!this._pseudoClassSet[p.name]) {
+                    this._pseudoClassSet[p.name] = p;
                 }
             });
-            provider.providePseudoElements().forEach(function (p) {
-                if (!_this._pseudoElementSet[p.name]) {
-                    _this._pseudoElementSet[p.name] = p;
+            provider.providePseudoElements().forEach(p => {
+                if (!this._pseudoElementSet[p.name]) {
+                    this._pseudoElementSet[p.name] = p;
                 }
             });
         });
@@ -63,30 +61,28 @@ var CSSDataManager = /** @class */ (function () {
         this._atDirectives = objects.values(this._atDirectiveSet);
         this._pseudoClasses = objects.values(this._pseudoClassSet);
         this._pseudoElements = objects.values(this._pseudoElementSet);
-    };
-    CSSDataManager.prototype.getProperty = function (name) { return this._propertySet[name]; };
-    CSSDataManager.prototype.getAtDirective = function (name) { return this._atDirectiveSet[name]; };
-    CSSDataManager.prototype.getPseudoClass = function (name) { return this._pseudoClassSet[name]; };
-    CSSDataManager.prototype.getPseudoElement = function (name) { return this._pseudoElementSet[name]; };
-    CSSDataManager.prototype.getProperties = function () {
+    }
+    getProperty(name) { return this._propertySet[name]; }
+    getAtDirective(name) { return this._atDirectiveSet[name]; }
+    getPseudoClass(name) { return this._pseudoClassSet[name]; }
+    getPseudoElement(name) { return this._pseudoElementSet[name]; }
+    getProperties() {
         return this._properties;
-    };
-    CSSDataManager.prototype.getAtDirectives = function () {
+    }
+    getAtDirectives() {
         return this._atDirectives;
-    };
-    CSSDataManager.prototype.getPseudoClasses = function () {
+    }
+    getPseudoClasses() {
         return this._pseudoClasses;
-    };
-    CSSDataManager.prototype.getPseudoElements = function () {
+    }
+    getPseudoElements() {
         return this._pseudoElements;
-    };
-    CSSDataManager.prototype.isKnownProperty = function (name) {
+    }
+    isKnownProperty(name) {
         return name.toLowerCase() in this._propertySet;
-    };
-    CSSDataManager.prototype.isStandardProperty = function (name) {
+    }
+    isStandardProperty(name) {
         return this.isKnownProperty(name) &&
             (!this._propertySet[name.toLowerCase()].status || this._propertySet[name.toLowerCase()].status === 'standard');
-    };
-    return CSSDataManager;
-}());
-export { CSSDataManager };
+    }
+}

package/lib/esm/languageFacts/dataProvider.js

@@ -3,68 +3,62 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-var CSSDataProvider = /** @class */ (function () {
+export class CSSDataProvider {
     /**
      * Currently, unversioned data uses the V1 implementation
      * In the future when the provider handles multiple versions of HTML custom data,
      * use the latest implementation for unversioned data
      */
-    function CSSDataProvider(data) {
+    constructor(data) {
         this._properties = [];
         this._atDirectives = [];
         this._pseudoClasses = [];
         this._pseudoElements = [];
         this.addData(data);
     }
-    CSSDataProvider.prototype.provideProperties = function () {
+    provideProperties() {
         return this._properties;
-    };
-    CSSDataProvider.prototype.provideAtDirectives = function () {
+    }
+    provideAtDirectives() {
         return this._atDirectives;
-    };
-    CSSDataProvider.prototype.providePseudoClasses = function () {
+    }
+    providePseudoClasses() {
         return this._pseudoClasses;
-    };
-    CSSDataProvider.prototype.providePseudoElements = function () {
+    }
+    providePseudoElements() {
         return this._pseudoElements;
-    };
-    CSSDataProvider.prototype.addData = function (data) {
+    }
+    addData(data) {
         if (Array.isArray(data.properties)) {
-            for (var _i = 0, _a = data.properties; _i < _a.length; _i++) {
-                var prop = _a[_i];
+            for (const prop of data.properties) {
                 if (isPropertyData(prop)) {
                     this._properties.push(prop);
                 }
             }
         }
         if (Array.isArray(data.atDirectives)) {
-            for (var _b = 0, _c = data.atDirectives; _b < _c.length; _b++) {
-                var prop = _c[_b];
+            for (const prop of data.atDirectives) {
                 if (isAtDirective(prop)) {
                     this._atDirectives.push(prop);
                 }
             }
         }
         if (Array.isArray(data.pseudoClasses)) {
-            for (var _d = 0, _e = data.pseudoClasses; _d < _e.length; _d++) {
-                var prop = _e[_d];
+            for (const prop of data.pseudoClasses) {
                 if (isPseudoClassData(prop)) {
                     this._pseudoClasses.push(prop);
                 }
             }
         }
         if (Array.isArray(data.pseudoElements)) {
-            for (var _f = 0, _g = data.pseudoElements; _f < _g.length; _f++) {
-                var prop = _g[_f];
+            for (const prop of data.pseudoElements) {
                 if (isPseudoElementData(prop)) {
                     this._pseudoElements.push(prop);
                 }
             }
         }
-    };
-    return CSSDataProvider;
-}());
-export { CSSDataProvider };
+    }
+}
 function isPropertyData(d) {
     return typeof d.name === 'string';
 }