vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/esm/parser/cssSymbolScope.js

@@ -3,129 +3,105 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-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 __());
-    };
-})();
 import * as nodes from './cssNodes';
 import { findFirst } from '../utils/arrays';
-var Scope = /** @class */ (function () {
-    function Scope(offset, length) {
+export 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 = findFirst(this.children, function (s) { return s.offset > end; });
+        const end = offset + length;
+        const idx = 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;
-}());
-export { Scope };
-var GlobalScope = /** @class */ (function (_super) {
-    __extends(GlobalScope, _super);
-    function GlobalScope() {
-        return _super.call(this, 0, Number.MAX_VALUE) || this;
     }
-    return GlobalScope;
-}(Scope));
-export { GlobalScope };
-var Symbol = /** @class */ (function () {
-    function Symbol(name, value, node, type) {
+}
+export class GlobalScope extends Scope {
+    constructor() {
+        super(0, Number.MAX_VALUE);
+    }
+}
+export class Symbol {
+    constructor(name, value, node, type) {
         this.name = name;
         this.value = value;
         this.node = node;
         this.type = type;
     }
-    return Symbol;
-}());
-export { Symbol };
-var ScopeBuilder = /** @class */ (function () {
-    function ScopeBuilder(scope) {
+}
+export 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);
@@ -149,32 +125,30 @@ var ScopeBuilder = /** @class */ (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));
@@ -183,48 +157,46 @@ var ScopeBuilder = /** @class */ (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;
-}());
-export { ScopeBuilder };
-var Symbols = /** @class */ (function () {
-    function Symbols(node) {
+    }
+}
+export 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;
@@ -233,16 +205,16 @@ var Symbols = /** @class */ (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();
                 }
@@ -251,12 +223,12 @@ var Symbols = /** @class */ (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;
                 }
@@ -264,10 +236,10 @@ var Symbols = /** @class */ (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;
             }
@@ -276,9 +248,9 @@ var Symbols = /** @class */ (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];
@@ -289,26 +261,26 @@ var Symbols = /** @class */ (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;
         }
@@ -318,24 +290,22 @@ var Symbols = /** @class */ (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;
-}());
-export { Symbols };
+    }
+}