vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/umd/parser/cssSymbolScope.js

@@ -1,18 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -29,114 +14,108 @@ var __extends = (this && this.__extends) || (function () {
     'use strict';
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Symbols = exports.ScopeBuilder = exports.Symbol = exports.GlobalScope = exports.Scope = void 0;
-    var nodes = require("./cssNodes");
-    var arrays_1 = require("../utils/arrays");
-    var Scope = /** @class */ (function () {
-        function Scope(offset, length) {
+    const nodes = require("./cssNodes");
+    const arrays_1 = require("../utils/arrays");
+    class Scope {
+        constructor(offset, length) {
             this.offset = offset;
             this.length = length;
             this.symbols = [];
             this.parent = null;
             this.children = [];
         }
-        Scope.prototype.addChild = function (scope) {
+        addChild(scope) {
             this.children.push(scope);
             scope.setParent(this);
-        };
-        Scope.prototype.setParent = function (scope) {
+        }
+        setParent(scope) {
             this.parent = scope;
-        };
-        Scope.prototype.findScope = function (offset, length) {
-            if (length === void 0) { length = 0; }
+        }
+        findScope(offset, length = 0) {
             if (this.offset <= offset && this.offset + this.length > offset + length || this.offset === offset && this.length === length) {
                 return this.findInScope(offset, length);
             }
             return null;
-        };
-        Scope.prototype.findInScope = function (offset, length) {
-            if (length === void 0) { length = 0; }
+        }
+        findInScope(offset, length = 0) {
             // find the first scope child that has an offset larger than offset + length
-            var end = offset + length;
-            var idx = (0, arrays_1.findFirst)(this.children, function (s) { return s.offset > end; });
+            const end = offset + length;
+            const idx = (0, arrays_1.findFirst)(this.children, s => s.offset > end);
             if (idx === 0) {
                 // all scopes have offsets larger than our end
                 return this;
             }
-            var res = this.children[idx - 1];
+            const res = this.children[idx - 1];
             if (res.offset <= offset && res.offset + res.length >= offset + length) {
                 return res.findInScope(offset, length);
             }
             return this;
-        };
-        Scope.prototype.addSymbol = function (symbol) {
+        }
+        addSymbol(symbol) {
             this.symbols.push(symbol);
-        };
-        Scope.prototype.getSymbol = function (name, type) {
-            for (var index = 0; index < this.symbols.length; index++) {
-                var symbol = this.symbols[index];
+        }
+        getSymbol(name, type) {
+            for (let index = 0; index < this.symbols.length; index++) {
+                const symbol = this.symbols[index];
                 if (symbol.name === name && symbol.type === type) {
                     return symbol;
                 }
             }
             return null;
-        };
-        Scope.prototype.getSymbols = function () {
+        }
+        getSymbols() {
             return this.symbols;
-        };
-        return Scope;
-    }());
+        }
+    }
     exports.Scope = Scope;
-    var GlobalScope = /** @class */ (function (_super) {
-        __extends(GlobalScope, _super);
-        function GlobalScope() {
-            return _super.call(this, 0, Number.MAX_VALUE) || this;
+    class GlobalScope extends Scope {
+        constructor() {
+            super(0, Number.MAX_VALUE);
         }
-        return GlobalScope;
-    }(Scope));
+    }
     exports.GlobalScope = GlobalScope;
-    var Symbol = /** @class */ (function () {
-        function Symbol(name, value, node, type) {
+    class Symbol {
+        constructor(name, value, node, type) {
             this.name = name;
             this.value = value;
             this.node = node;
             this.type = type;
         }
-        return Symbol;
-    }());
+    }
     exports.Symbol = Symbol;
-    var ScopeBuilder = /** @class */ (function () {
-        function ScopeBuilder(scope) {
+    class ScopeBuilder {
+        constructor(scope) {
             this.scope = scope;
         }
-        ScopeBuilder.prototype.addSymbol = function (node, name, value, type) {
+        addSymbol(node, name, value, type) {
             if (node.offset !== -1) {
-                var current = this.scope.findScope(node.offset, node.length);
+                const current = this.scope.findScope(node.offset, node.length);
                 if (current) {
                     current.addSymbol(new Symbol(name, value, node, type));
                 }
             }
-        };
-        ScopeBuilder.prototype.addScope = function (node) {
+        }
+        addScope(node) {
             if (node.offset !== -1) {
-                var current = this.scope.findScope(node.offset, node.length);
+                const current = this.scope.findScope(node.offset, node.length);
                 if (current && (current.offset !== node.offset || current.length !== node.length)) { // scope already known?
-                    var newScope = new Scope(node.offset, node.length);
+                    const newScope = new Scope(node.offset, node.length);
                     current.addChild(newScope);
                     return newScope;
                 }
                 return current;
             }
             return null;
-        };
-        ScopeBuilder.prototype.addSymbolToChildScope = function (scopeNode, node, name, value, type) {
+        }
+        addSymbolToChildScope(scopeNode, node, name, value, type) {
             if (scopeNode && scopeNode.offset !== -1) {
-                var current = this.addScope(scopeNode); // create the scope or gets the existing one
+                const current = this.addScope(scopeNode); // create the scope or gets the existing one
                 if (current) {
                     current.addSymbol(new Symbol(name, value, node, type));
                 }
             }
-        };
-        ScopeBuilder.prototype.visitNode = function (node) {
+        }
+        visitNode(node) {
             switch (node.type) {
                 case nodes.NodeType.Keyframe:
                     this.addSymbol(node, node.getName(), void 0, nodes.ReferenceType.Keyframe);
@@ -160,32 +139,30 @@ var __extends = (this && this.__extends) || (function () {
                     this.addScope(node);
                     return true;
                 case nodes.NodeType.For:
-                    var forNode = node;
-                    var scopeNode = forNode.getDeclarations();
+                    const forNode = node;
+                    const scopeNode = forNode.getDeclarations();
                     if (scopeNode && forNode.variable) {
                         this.addSymbolToChildScope(scopeNode, forNode.variable, forNode.variable.getName(), void 0, nodes.ReferenceType.Variable);
                     }
                     return true;
                 case nodes.NodeType.Each: {
-                    var eachNode = node;
-                    var scopeNode_1 = eachNode.getDeclarations();
-                    if (scopeNode_1) {
-                        var variables = eachNode.getVariables().getChildren();
-                        for (var _i = 0, variables_1 = variables; _i < variables_1.length; _i++) {
-                            var variable = variables_1[_i];
-                            this.addSymbolToChildScope(scopeNode_1, variable, variable.getName(), void 0, nodes.ReferenceType.Variable);
+                    const eachNode = node;
+                    const scopeNode = eachNode.getDeclarations();
+                    if (scopeNode) {
+                        const variables = eachNode.getVariables().getChildren();
+                        for (const variable of variables) {
+                            this.addSymbolToChildScope(scopeNode, variable, variable.getName(), void 0, nodes.ReferenceType.Variable);
                         }
                     }
                     return true;
                 }
             }
             return true;
-        };
-        ScopeBuilder.prototype.visitRuleSet = function (node) {
-            var current = this.scope.findScope(node.offset, node.length);
+        }
+        visitRuleSet(node) {
+            const current = this.scope.findScope(node.offset, node.length);
             if (current) {
-                for (var _i = 0, _a = node.getSelectors().getChildren(); _i < _a.length; _i++) {
-                    var child = _a[_i];
+                for (const child of node.getSelectors().getChildren()) {
                     if (child instanceof nodes.Selector) {
                         if (child.getChildren().length === 1) { // only selectors with a single element can be extended
                             current.addSymbol(new Symbol(child.getChild(0).getText(), void 0, child, nodes.ReferenceType.Rule));
@@ -194,48 +171,47 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             return true;
-        };
-        ScopeBuilder.prototype.visitVariableDeclarationNode = function (node) {
-            var value = node.getValue() ? node.getValue().getText() : void 0;
+        }
+        visitVariableDeclarationNode(node) {
+            const value = node.getValue() ? node.getValue().getText() : void 0;
             this.addSymbol(node, node.getName(), value, nodes.ReferenceType.Variable);
             return true;
-        };
-        ScopeBuilder.prototype.visitFunctionParameterNode = function (node) {
+        }
+        visitFunctionParameterNode(node) {
             // parameters are part of the body scope
-            var scopeNode = node.getParent().getDeclarations();
+            const scopeNode = node.getParent().getDeclarations();
             if (scopeNode) {
-                var valueNode = node.getDefaultValue();
-                var value = valueNode ? valueNode.getText() : void 0;
+                const valueNode = node.getDefaultValue();
+                const value = valueNode ? valueNode.getText() : void 0;
                 this.addSymbolToChildScope(scopeNode, node, node.getName(), value, nodes.ReferenceType.Variable);
             }
             return true;
-        };
-        ScopeBuilder.prototype.visitCustomPropertyDeclarationNode = function (node) {
-            var value = node.getValue() ? node.getValue().getText() : '';
+        }
+        visitCustomPropertyDeclarationNode(node) {
+            const value = node.getValue() ? node.getValue().getText() : '';
             this.addCSSVariable(node.getProperty(), node.getProperty().getName(), value, nodes.ReferenceType.Variable);
             return true;
-        };
-        ScopeBuilder.prototype.addCSSVariable = function (node, name, value, type) {
+        }
+        addCSSVariable(node, name, value, type) {
             if (node.offset !== -1) {
                 this.scope.addSymbol(new Symbol(name, value, node, type));
             }
-        };
-        return ScopeBuilder;
-    }());
+        }
+    }
     exports.ScopeBuilder = ScopeBuilder;
-    var Symbols = /** @class */ (function () {
-        function Symbols(node) {
+    class Symbols {
+        constructor(node) {
             this.global = new GlobalScope();
             node.acceptVisitor(new ScopeBuilder(this.global));
         }
-        Symbols.prototype.findSymbolsAtOffset = function (offset, referenceType) {
-            var scope = this.global.findScope(offset, 0);
-            var result = [];
-            var names = {};
+        findSymbolsAtOffset(offset, referenceType) {
+            let scope = this.global.findScope(offset, 0);
+            const result = [];
+            const names = {};
             while (scope) {
-                var symbols = scope.getSymbols();
-                for (var i = 0; i < symbols.length; i++) {
-                    var symbol = symbols[i];
+                const symbols = scope.getSymbols();
+                for (let i = 0; i < symbols.length; i++) {
+                    const symbol = symbols[i];
                     if (symbol.type === referenceType && !names[symbol.name]) {
                         result.push(symbol);
                         names[symbol.name] = true;
@@ -244,16 +220,16 @@ var __extends = (this && this.__extends) || (function () {
                 scope = scope.parent;
             }
             return result;
-        };
-        Symbols.prototype.internalFindSymbol = function (node, referenceTypes) {
-            var scopeNode = node;
+        }
+        internalFindSymbol(node, referenceTypes) {
+            let scopeNode = node;
             if (node.parent instanceof nodes.FunctionParameter && node.parent.getParent() instanceof nodes.BodyDeclaration) {
                 scopeNode = node.parent.getParent().getDeclarations();
             }
             if (node.parent instanceof nodes.FunctionArgument && node.parent.getParent() instanceof nodes.Function) {
-                var funcId = node.parent.getParent().getIdentifier();
+                const funcId = node.parent.getParent().getIdentifier();
                 if (funcId) {
-                    var functionSymbol = this.internalFindSymbol(funcId, [nodes.ReferenceType.Function]);
+                    const functionSymbol = this.internalFindSymbol(funcId, [nodes.ReferenceType.Function]);
                     if (functionSymbol) {
                         scopeNode = functionSymbol.node.getDeclarations();
                     }
@@ -262,12 +238,12 @@ var __extends = (this && this.__extends) || (function () {
             if (!scopeNode) {
                 return null;
             }
-            var name = node.getText();
-            var scope = this.global.findScope(scopeNode.offset, scopeNode.length);
+            const name = node.getText();
+            let scope = this.global.findScope(scopeNode.offset, scopeNode.length);
             while (scope) {
-                for (var index = 0; index < referenceTypes.length; index++) {
-                    var type = referenceTypes[index];
-                    var symbol = scope.getSymbol(name, type);
+                for (let index = 0; index < referenceTypes.length; index++) {
+                    const type = referenceTypes[index];
+                    const symbol = scope.getSymbol(name, type);
                     if (symbol) {
                         return symbol;
                     }
@@ -275,10 +251,10 @@ var __extends = (this && this.__extends) || (function () {
                 scope = scope.parent;
             }
             return null;
-        };
-        Symbols.prototype.evaluateReferenceTypes = function (node) {
+        }
+        evaluateReferenceTypes(node) {
             if (node instanceof nodes.Identifier) {
-                var referenceTypes = node.referenceTypes;
+                const referenceTypes = node.referenceTypes;
                 if (referenceTypes) {
                     return referenceTypes;
                 }
@@ -287,9 +263,9 @@ var __extends = (this && this.__extends) || (function () {
                         return [nodes.ReferenceType.Variable];
                     }
                     // are a reference to a keyframe?
-                    var decl = nodes.getParentDeclaration(node);
+                    const decl = nodes.getParentDeclaration(node);
                     if (decl) {
-                        var propertyName = decl.getNonPrefixedPropertyName();
+                        const propertyName = decl.getNonPrefixedPropertyName();
                         if ((propertyName === 'animation' || propertyName === 'animation-name')
                             && decl.getValue() && decl.getValue().offset === node.offset) {
                             return [nodes.ReferenceType.Keyframe];
@@ -300,26 +276,26 @@ var __extends = (this && this.__extends) || (function () {
             else if (node instanceof nodes.Variable) {
                 return [nodes.ReferenceType.Variable];
             }
-            var selector = node.findAParent(nodes.NodeType.Selector, nodes.NodeType.ExtendsReference);
+            const selector = node.findAParent(nodes.NodeType.Selector, nodes.NodeType.ExtendsReference);
             if (selector) {
                 return [nodes.ReferenceType.Rule];
             }
             return null;
-        };
-        Symbols.prototype.findSymbolFromNode = function (node) {
+        }
+        findSymbolFromNode(node) {
             if (!node) {
                 return null;
             }
             while (node.type === nodes.NodeType.Interpolation) {
                 node = node.getParent();
             }
-            var referenceTypes = this.evaluateReferenceTypes(node);
+            const referenceTypes = this.evaluateReferenceTypes(node);
             if (referenceTypes) {
                 return this.internalFindSymbol(node, referenceTypes);
             }
             return null;
-        };
-        Symbols.prototype.matchesSymbol = function (node, symbol) {
+        }
+        matchesSymbol(node, symbol) {
             if (!node) {
                 return false;
             }
@@ -329,25 +305,24 @@ var __extends = (this && this.__extends) || (function () {
             if (!node.matches(symbol.name)) {
                 return false;
             }
-            var referenceTypes = this.evaluateReferenceTypes(node);
+            const referenceTypes = this.evaluateReferenceTypes(node);
             if (!referenceTypes || referenceTypes.indexOf(symbol.type) === -1) {
                 return false;
             }
-            var nodeSymbol = this.internalFindSymbol(node, referenceTypes);
+            const nodeSymbol = this.internalFindSymbol(node, referenceTypes);
             return nodeSymbol === symbol;
-        };
-        Symbols.prototype.findSymbol = function (name, type, offset) {
-            var scope = this.global.findScope(offset);
+        }
+        findSymbol(name, type, offset) {
+            let scope = this.global.findScope(offset);
             while (scope) {
-                var symbol = scope.getSymbol(name, type);
+                const symbol = scope.getSymbol(name, type);
                 if (symbol) {
                     return symbol;
                 }
                 scope = scope.parent;
             }
             return null;
-        };
-        return Symbols;
-    }());
+        }
+    }
     exports.Symbols = Symbols;
 });