vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/esm/parser/lessParser.js

@@ -3,21 +3,6 @@
  *  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 lessScanner from './lessScanner';
 import { TokenType } from './cssScanner';
 import * as cssParser from './cssParser';
@@ -27,28 +12,26 @@ import { ParseError } from './cssErrors';
 /// A parser for LESS
 /// http://lesscss.org/
 /// </summary>
-var LESSParser = /** @class */ (function (_super) {
-    __extends(LESSParser, _super);
-    function LESSParser() {
-        return _super.call(this, new lessScanner.LESSScanner()) || this;
+export class LESSParser extends cssParser.Parser {
+    constructor() {
+        super(new lessScanner.LESSScanner());
     }
-    LESSParser.prototype._parseStylesheetStatement = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    _parseStylesheetStatement(isNested = false) {
         if (this.peek(TokenType.AtKeyword)) {
             return this._parseVariableDeclaration()
                 || this._parsePlugin()
-                || _super.prototype._parseStylesheetAtStatement.call(this, isNested);
+                || super._parseStylesheetAtStatement(isNested);
         }
         return this._tryParseMixinDeclaration()
             || this._tryParseMixinReference()
             || this._parseFunction()
             || this._parseRuleset(true);
-    };
-    LESSParser.prototype._parseImport = function () {
+    }
+    _parseImport() {
         if (!this.peekKeyword('@import') && !this.peekKeyword('@import-once') /* deprecated in less 1.4.1 */) {
             return null;
         }
-        var node = this.create(nodes.Import);
+        const node = this.create(nodes.Import);
         this.consumeToken();
         // less 1.4.1: @import (css) "lib"
         if (this.accept(TokenType.ParenthesisL)) {
@@ -71,12 +54,12 @@ var LESSParser = /** @class */ (function (_super) {
             node.setMedialist(this._parseMediaQueryList());
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parsePlugin = function () {
+    }
+    _parsePlugin() {
         if (!this.peekKeyword('@plugin')) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.Plugin);
+        const node = this.createNode(nodes.NodeType.Plugin);
         this.consumeToken(); // @import
         if (!node.addChild(this._parseStringLiteral())) {
             return this.finish(node, ParseError.StringLiteralExpected);
@@ -85,34 +68,32 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node, ParseError.SemiColonExpected);
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseMediaQuery = function () {
-        var node = _super.prototype._parseMediaQuery.call(this);
+    }
+    _parseMediaQuery() {
+        const node = super._parseMediaQuery();
         if (!node) {
-            var node_1 = this.create(nodes.MediaQuery);
-            if (node_1.addChild(this._parseVariable())) {
-                return this.finish(node_1);
+            const node = this.create(nodes.MediaQuery);
+            if (node.addChild(this._parseVariable())) {
+                return this.finish(node);
             }
             return null;
         }
         return node;
-    };
-    LESSParser.prototype._parseMediaDeclaration = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseMediaDeclaration(isNested = false) {
         return this._tryParseRuleset(isNested)
             || this._tryToParseDeclaration()
             || this._tryParseMixinDeclaration()
             || this._tryParseMixinReference()
             || this._parseDetachedRuleSetMixin()
             || this._parseStylesheetStatement(isNested);
-    };
-    LESSParser.prototype._parseMediaFeatureName = function () {
+    }
+    _parseMediaFeatureName() {
         return this._parseIdent() || this._parseVariable();
-    };
-    LESSParser.prototype._parseVariableDeclaration = function (panic) {
-        if (panic === void 0) { panic = []; }
-        var node = this.create(nodes.VariableDeclaration);
-        var mark = this.mark();
+    }
+    _parseVariableDeclaration(panic = []) {
+        const node = this.create(nodes.VariableDeclaration);
+        const mark = this.mark();
         if (!node.setVariable(this._parseVariable(true))) {
             return null;
         }
@@ -136,14 +117,14 @@ var LESSParser = /** @class */ (function (_super) {
             node.semicolonPosition = this.token.offset; // not part of the declaration, but useful information for code assist
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseDetachedRuleSet = function () {
-        var mark = this.mark();
+    }
+    _parseDetachedRuleSet() {
+        let mark = this.mark();
         // "Anonymous mixin" used in each() and possibly a generic type in the future
         if (this.peekDelim('#') || this.peekDelim('.')) {
             this.consumeToken();
             if (!this.hasWhitespace() && this.accept(TokenType.ParenthesisL)) {
-                var node = this.create(nodes.MixinDeclaration);
+                let node = this.create(nodes.MixinDeclaration);
                 if (node.getParameters().addChild(this._parseMixinParameter())) {
                     while (this.accept(TokenType.Comma) || this.accept(TokenType.SemiColon)) {
                         if (this.peek(TokenType.ParenthesisR)) {
@@ -167,18 +148,18 @@ var LESSParser = /** @class */ (function (_super) {
         if (!this.peek(TokenType.CurlyL)) {
             return null;
         }
-        var content = this.create(nodes.BodyDeclaration);
+        const content = this.create(nodes.BodyDeclaration);
         this._parseBody(content, this._parseDetachedRuleSetBody.bind(this));
         return this.finish(content);
-    };
-    LESSParser.prototype._parseDetachedRuleSetBody = function () {
+    }
+    _parseDetachedRuleSetBody() {
         return this._tryParseKeyframeSelector() || this._parseRuleSetDeclaration();
-    };
-    LESSParser.prototype._addLookupChildren = function (node) {
+    }
+    _addLookupChildren(node) {
         if (!node.addChild(this._parseLookupValue())) {
             return false;
         }
-        var expectsValue = false;
+        let expectsValue = false;
         while (true) {
             if (this.peek(TokenType.BracketL)) {
                 expectsValue = true;
@@ -189,10 +170,10 @@ var LESSParser = /** @class */ (function (_super) {
             expectsValue = false;
         }
         return !expectsValue;
-    };
-    LESSParser.prototype._parseLookupValue = function () {
-        var node = this.create(nodes.Node);
-        var mark = this.mark();
+    }
+    _parseLookupValue() {
+        const node = this.create(nodes.Node);
+        const mark = this.mark();
         if (!this.accept(TokenType.BracketL)) {
             this.restoreAtMark(mark);
             return null;
@@ -204,16 +185,14 @@ var LESSParser = /** @class */ (function (_super) {
         }
         this.restoreAtMark(mark);
         return null;
-    };
-    LESSParser.prototype._parseVariable = function (declaration, insideLookup) {
-        if (declaration === void 0) { declaration = false; }
-        if (insideLookup === void 0) { insideLookup = false; }
-        var isPropertyReference = !declaration && this.peekDelim('$');
+    }
+    _parseVariable(declaration = false, insideLookup = false) {
+        const isPropertyReference = !declaration && this.peekDelim('$');
         if (!this.peekDelim('@') && !isPropertyReference && !this.peek(TokenType.AtKeyword)) {
             return null;
         }
-        var node = this.create(nodes.Variable);
-        var mark = this.mark();
+        const node = this.create(nodes.Variable);
+        const mark = this.mark();
         while (this.acceptDelim('@') || (!declaration && this.acceptDelim('$'))) {
             if (this.hasWhitespace()) {
                 this.restoreAtMark(mark);
@@ -231,22 +210,22 @@ var LESSParser = /** @class */ (function (_super) {
             }
         }
         return node;
-    };
-    LESSParser.prototype._parseTermExpression = function () {
+    }
+    _parseTermExpression() {
         return this._parseVariable() ||
             this._parseEscaped() ||
-            _super.prototype._parseTermExpression.call(this) || // preference for colors before mixin references
+            super._parseTermExpression() || // preference for colors before mixin references
             this._tryParseMixinReference(false);
-    };
-    LESSParser.prototype._parseEscaped = function () {
+    }
+    _parseEscaped() {
         if (this.peek(TokenType.EscapedJavaScript) ||
             this.peek(TokenType.BadEscapedJavaScript)) {
-            var node = this.createNode(nodes.NodeType.EscapedValue);
+            const node = this.createNode(nodes.NodeType.EscapedValue);
             this.consumeToken();
             return this.finish(node);
         }
         if (this.peekDelim('~')) {
-            var node = this.createNode(nodes.NodeType.EscapedValue);
+            const node = this.createNode(nodes.NodeType.EscapedValue);
             this.consumeToken();
             if (this.accept(TokenType.String) || this.accept(TokenType.EscapedJavaScript)) {
                 return this.finish(node);
@@ -256,75 +235,76 @@ var LESSParser = /** @class */ (function (_super) {
             }
         }
         return null;
-    };
-    LESSParser.prototype._parseOperator = function () {
-        var node = this._parseGuardOperator();
+    }
+    _parseOperator() {
+        const node = this._parseGuardOperator();
         if (node) {
             return node;
         }
         else {
-            return _super.prototype._parseOperator.call(this);
+            return super._parseOperator();
         }
-    };
-    LESSParser.prototype._parseGuardOperator = function () {
+    }
+    _parseGuardOperator() {
         if (this.peekDelim('>')) {
-            var node = this.createNode(nodes.NodeType.Operator);
+            const node = this.createNode(nodes.NodeType.Operator);
             this.consumeToken();
             this.acceptDelim('=');
             return node;
         }
         else if (this.peekDelim('=')) {
-            var node = this.createNode(nodes.NodeType.Operator);
+            const node = this.createNode(nodes.NodeType.Operator);
             this.consumeToken();
             this.acceptDelim('<');
             return node;
         }
         else if (this.peekDelim('<')) {
-            var node = this.createNode(nodes.NodeType.Operator);
+            const node = this.createNode(nodes.NodeType.Operator);
             this.consumeToken();
             this.acceptDelim('=');
             return node;
         }
         return null;
-    };
-    LESSParser.prototype._parseRuleSetDeclaration = function () {
+    }
+    _parseRuleSetDeclaration() {
         if (this.peek(TokenType.AtKeyword)) {
             return this._parseKeyframe()
                 || this._parseMedia(true)
                 || this._parseImport()
                 || this._parseSupports(true) // @supports
+                || this._parseLayer() // @layer
                 || this._parseDetachedRuleSetMixin() // less detached ruleset mixin
                 || this._parseVariableDeclaration() // Variable declarations
-                || _super.prototype._parseRuleSetDeclarationAtStatement.call(this);
+                || super._parseRuleSetDeclarationAtStatement();
         }
         return this._tryParseMixinDeclaration()
             || this._tryParseRuleset(true) // nested ruleset
             || this._tryParseMixinReference() // less mixin reference
             || this._parseFunction()
             || this._parseExtend() // less extend declaration
-            || _super.prototype._parseRuleSetDeclaration.call(this); // try css ruleset declaration as the last option
-    };
-    LESSParser.prototype._parseKeyframeIdent = function () {
+            || super._parseRuleSetDeclaration(); // try css ruleset declaration as the last option
+    }
+    _parseKeyframeIdent() {
         return this._parseIdent([nodes.ReferenceType.Keyframe]) || this._parseVariable();
-    };
-    LESSParser.prototype._parseKeyframeSelector = function () {
+    }
+    _parseKeyframeSelector() {
         return this._parseDetachedRuleSetMixin() // less detached ruleset mixin
-            || _super.prototype._parseKeyframeSelector.call(this);
-    };
-    LESSParser.prototype._parseSimpleSelectorBody = function () {
-        return this._parseSelectorCombinator() || _super.prototype._parseSimpleSelectorBody.call(this);
-    };
-    LESSParser.prototype._parseSelector = function (isNested) {
+            || super._parseKeyframeSelector();
+    }
+    _parseSimpleSelectorBody() {
+        return this._parseSelectorCombinator() || super._parseSimpleSelectorBody();
+    }
+    _parseSelector(isNested) {
         // CSS Guards
-        var node = this.create(nodes.Selector);
-        var hasContent = false;
+        const node = this.create(nodes.Selector);
+        let hasContent = false;
         if (isNested) {
             // nested selectors can start with a combinator
             hasContent = node.addChild(this._parseCombinator());
         }
         while (node.addChild(this._parseSimpleSelector())) {
             hasContent = true;
-            var mark = this.mark();
+            const mark = this.mark();
             if (node.addChild(this._parseGuard()) && this.peek(TokenType.CurlyL)) {
                 break;
             }
@@ -332,10 +312,10 @@ var LESSParser = /** @class */ (function (_super) {
             node.addChild(this._parseCombinator()); // optional
         }
         return hasContent ? this.finish(node) : null;
-    };
-    LESSParser.prototype._parseSelectorCombinator = function () {
+    }
+    _parseSelectorCombinator() {
         if (this.peekDelim('&')) {
-            var node = this.createNode(nodes.NodeType.SelectorCombinator);
+            const node = this.createNode(nodes.NodeType.SelectorCombinator);
             this.consumeToken();
             while (!this.hasWhitespace() && (this.acceptDelim('-') || this.accept(TokenType.Num) || this.accept(TokenType.Dimension) || node.addChild(this._parseIdent()) || this.acceptDelim('&'))) {
                 //  support &-foo
@@ -343,25 +323,24 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node);
         }
         return null;
-    };
-    LESSParser.prototype._parseSelectorIdent = function () {
+    }
+    _parseSelectorIdent() {
         if (!this.peekInterpolatedIdent()) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.SelectorInterpolation);
-        var hasContent = this._acceptInterpolatedIdent(node);
+        const node = this.createNode(nodes.NodeType.SelectorInterpolation);
+        const hasContent = this._acceptInterpolatedIdent(node);
         return hasContent ? this.finish(node) : null;
-    };
-    LESSParser.prototype._parsePropertyIdentifier = function (inLookup) {
-        if (inLookup === void 0) { inLookup = false; }
-        var propertyRegex = /^[\w-]+/;
+    }
+    _parsePropertyIdentifier(inLookup = false) {
+        const propertyRegex = /^[\w-]+/;
         if (!this.peekInterpolatedIdent() && !this.peekRegExp(this.token.type, propertyRegex)) {
             return null;
         }
-        var mark = this.mark();
-        var node = this.create(nodes.Identifier);
+        const mark = this.mark();
+        const node = this.create(nodes.Identifier);
         node.isCustomProperty = this.acceptDelim('-') && this.acceptDelim('-');
-        var childAdded = false;
+        let childAdded = false;
         if (!inLookup) {
             if (node.isCustomProperty) {
                 childAdded = this._acceptInterpolatedIdent(node);
@@ -389,32 +368,31 @@ var LESSParser = /** @class */ (function (_super) {
             }
         }
         return this.finish(node);
-    };
-    LESSParser.prototype.peekInterpolatedIdent = function () {
+    }
+    peekInterpolatedIdent() {
         return this.peek(TokenType.Ident) ||
             this.peekDelim('@') ||
             this.peekDelim('$') ||
             this.peekDelim('-');
-    };
-    LESSParser.prototype._acceptInterpolatedIdent = function (node, identRegex) {
-        var _this = this;
-        var hasContent = false;
-        var indentInterpolation = function () {
-            var pos = _this.mark();
-            if (_this.acceptDelim('-')) {
-                if (!_this.hasWhitespace()) {
-                    _this.acceptDelim('-');
+    }
+    _acceptInterpolatedIdent(node, identRegex) {
+        let hasContent = false;
+        const indentInterpolation = () => {
+            const pos = this.mark();
+            if (this.acceptDelim('-')) {
+                if (!this.hasWhitespace()) {
+                    this.acceptDelim('-');
                 }
-                if (_this.hasWhitespace()) {
-                    _this.restoreAtMark(pos);
+                if (this.hasWhitespace()) {
+                    this.restoreAtMark(pos);
                     return null;
                 }
             }
-            return _this._parseInterpolation();
+            return this._parseInterpolation();
         };
-        var accept = identRegex ?
-            function () { return _this.acceptRegexp(identRegex); } :
-            function () { return _this.accept(TokenType.Ident); };
+        const accept = identRegex ?
+            () => this.acceptRegexp(identRegex) :
+            () => this.accept(TokenType.Ident);
         while (accept() ||
             node.addChild(this._parseInterpolation() ||
                 this.try(indentInterpolation))) {
@@ -424,13 +402,13 @@ var LESSParser = /** @class */ (function (_super) {
             }
         }
         return hasContent;
-    };
-    LESSParser.prototype._parseInterpolation = function () {
+    }
+    _parseInterpolation() {
         // @{name} Variable or
         // ${name} Property
-        var mark = this.mark();
+        const mark = this.mark();
         if (this.peekDelim('@') || this.peekDelim('$')) {
-            var node = this.createNode(nodes.NodeType.Interpolation);
+            const node = this.createNode(nodes.NodeType.Interpolation);
             this.consumeToken();
             if (this.hasWhitespace() || !this.accept(TokenType.CurlyL)) {
                 this.restoreAtMark(mark);
@@ -445,10 +423,10 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node);
         }
         return null;
-    };
-    LESSParser.prototype._tryParseMixinDeclaration = function () {
-        var mark = this.mark();
-        var node = this.create(nodes.MixinDeclaration);
+    }
+    _tryParseMixinDeclaration() {
+        const mark = this.mark();
+        const node = this.create(nodes.MixinDeclaration);
         if (!node.setIdentifier(this._parseMixinDeclarationIdentifier()) || !this.accept(TokenType.ParenthesisL)) {
             this.restoreAtMark(mark);
             return null;
@@ -473,12 +451,12 @@ var LESSParser = /** @class */ (function (_super) {
             return null;
         }
         return this._parseBody(node, this._parseMixInBodyDeclaration.bind(this));
-    };
-    LESSParser.prototype._parseMixInBodyDeclaration = function () {
+    }
+    _parseMixInBodyDeclaration() {
         return this._parseFontFace() || this._parseRuleSetDeclaration();
-    };
-    LESSParser.prototype._parseMixinDeclarationIdentifier = function () {
-        var identifier;
+    }
+    _parseMixinDeclarationIdentifier() {
+        let identifier;
         if (this.peekDelim('#') || this.peekDelim('.')) {
             identifier = this.create(nodes.Identifier);
             this.consumeToken(); // # or .
@@ -495,38 +473,38 @@ var LESSParser = /** @class */ (function (_super) {
         }
         identifier.referenceTypes = [nodes.ReferenceType.Mixin];
         return this.finish(identifier);
-    };
-    LESSParser.prototype._parsePseudo = function () {
+    }
+    _parsePseudo() {
         if (!this.peek(TokenType.Colon)) {
             return null;
         }
-        var mark = this.mark();
-        var node = this.create(nodes.ExtendsReference);
+        const mark = this.mark();
+        const node = this.create(nodes.ExtendsReference);
         this.consumeToken(); // :
         if (this.acceptIdent('extend')) {
             return this._completeExtends(node);
         }
         this.restoreAtMark(mark);
-        return _super.prototype._parsePseudo.call(this);
-    };
-    LESSParser.prototype._parseExtend = function () {
+        return super._parsePseudo();
+    }
+    _parseExtend() {
         if (!this.peekDelim('&')) {
             return null;
         }
-        var mark = this.mark();
-        var node = this.create(nodes.ExtendsReference);
+        const mark = this.mark();
+        const node = this.create(nodes.ExtendsReference);
         this.consumeToken(); // &
         if (this.hasWhitespace() || !this.accept(TokenType.Colon) || !this.acceptIdent('extend')) {
             this.restoreAtMark(mark);
             return null;
         }
         return this._completeExtends(node);
-    };
-    LESSParser.prototype._completeExtends = function (node) {
+    }
+    _completeExtends(node) {
         if (!this.accept(TokenType.ParenthesisL)) {
             return this.finish(node, ParseError.LeftParenthesisExpected);
         }
-        var selectors = node.getSelectors();
+        const selectors = node.getSelectors();
         if (!selectors.addChild(this._parseSelector(true))) {
             return this.finish(node, ParseError.SelectorExpected);
         }
@@ -539,13 +517,13 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseDetachedRuleSetMixin = function () {
+    }
+    _parseDetachedRuleSetMixin() {
         if (!this.peek(TokenType.AtKeyword)) {
             return null;
         }
-        var mark = this.mark();
-        var node = this.create(nodes.MixinReference);
+        const mark = this.mark();
+        const node = this.create(nodes.MixinReference);
         if (node.addChild(this._parseVariable(true)) && (this.hasWhitespace() || !this.accept(TokenType.ParenthesisL))) {
             this.restoreAtMark(mark);
             return null;
@@ -554,15 +532,14 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._tryParseMixinReference = function (atRoot) {
-        if (atRoot === void 0) { atRoot = true; }
-        var mark = this.mark();
-        var node = this.create(nodes.MixinReference);
-        var identifier = this._parseMixinDeclarationIdentifier();
+    }
+    _tryParseMixinReference(atRoot = true) {
+        const mark = this.mark();
+        const node = this.create(nodes.MixinReference);
+        let identifier = this._parseMixinDeclarationIdentifier();
         while (identifier) {
             this.acceptDelim('>');
-            var nextId = this._parseMixinDeclarationIdentifier();
+            const nextId = this._parseMixinDeclarationIdentifier();
             if (nextId) {
                 node.getNamespaces().addChild(identifier);
                 identifier = nextId;
@@ -575,7 +552,7 @@ var LESSParser = /** @class */ (function (_super) {
             this.restoreAtMark(mark);
             return null;
         }
-        var hasArguments = false;
+        let hasArguments = false;
         if (this.accept(TokenType.ParenthesisL)) {
             hasArguments = true;
             if (node.getArguments().addChild(this._parseMixinArgument())) {
@@ -609,12 +586,12 @@ var LESSParser = /** @class */ (function (_super) {
             return null;
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseMixinArgument = function () {
+    }
+    _parseMixinArgument() {
         // [variableName ':'] expression | variableName '...'
-        var node = this.create(nodes.FunctionArgument);
-        var pos = this.mark();
-        var argument = this._parseVariable();
+        const node = this.create(nodes.FunctionArgument);
+        const pos = this.mark();
+        const argument = this._parseVariable();
         if (argument) {
             if (!this.accept(TokenType.Colon)) {
                 this.restoreAtMark(pos);
@@ -628,12 +605,12 @@ var LESSParser = /** @class */ (function (_super) {
         }
         this.restoreAtMark(pos);
         return null;
-    };
-    LESSParser.prototype._parseMixinParameter = function () {
-        var node = this.create(nodes.FunctionParameter);
+    }
+    _parseMixinParameter() {
+        const node = this.create(nodes.FunctionParameter);
         // special rest variable: @rest...
         if (this.peekKeyword('@rest')) {
-            var restNode = this.create(nodes.Node);
+            const restNode = this.create(nodes.Node);
             this.consumeToken();
             if (!this.accept(lessScanner.Ellipsis)) {
                 return this.finish(node, ParseError.DotExpected, [], [TokenType.Comma, TokenType.ParenthesisR]);
@@ -643,12 +620,12 @@ var LESSParser = /** @class */ (function (_super) {
         }
         // special const args: ...
         if (this.peek(lessScanner.Ellipsis)) {
-            var varargsNode = this.create(nodes.Node);
+            const varargsNode = this.create(nodes.Node);
             this.consumeToken();
             node.setIdentifier(this.finish(varargsNode));
             return this.finish(node);
         }
-        var hasContent = false;
+        let hasContent = false;
         // default variable declaration: @param: 12 or @name
         if (node.setIdentifier(this._parseVariable())) {
             this.accept(TokenType.Colon);
@@ -658,12 +635,12 @@ var LESSParser = /** @class */ (function (_super) {
             return null;
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseGuard = function () {
+    }
+    _parseGuard() {
         if (!this.peekIdent('when')) {
             return null;
         }
-        var node = this.create(nodes.LessGuard);
+        const node = this.create(nodes.LessGuard);
         this.consumeToken(); // when
         node.isNegated = this.acceptIdent('not');
         if (!node.getConditions().addChild(this._parseGuardCondition())) {
@@ -675,12 +652,12 @@ var LESSParser = /** @class */ (function (_super) {
             }
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseGuardCondition = function () {
+    }
+    _parseGuardCondition() {
         if (!this.peek(TokenType.ParenthesisL)) {
             return null;
         }
-        var node = this.create(nodes.GuardCondition);
+        const node = this.create(nodes.GuardCondition);
         this.consumeToken(); // ParenthesisL
         if (!node.addChild(this._parseExpr())) {
             // empty (?)
@@ -689,10 +666,10 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseFunction = function () {
-        var pos = this.mark();
-        var node = this.create(nodes.Function);
+    }
+    _parseFunction() {
+        const pos = this.mark();
+        const node = this.create(nodes.Function);
         if (!node.setIdentifier(this._parseFunctionIdentifier())) {
             return null;
         }
@@ -714,27 +691,25 @@ var LESSParser = /** @class */ (function (_super) {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    LESSParser.prototype._parseFunctionIdentifier = function () {
+    }
+    _parseFunctionIdentifier() {
         if (this.peekDelim('%')) {
-            var node = this.create(nodes.Identifier);
+            const node = this.create(nodes.Identifier);
             node.referenceTypes = [nodes.ReferenceType.Function];
             this.consumeToken();
             return this.finish(node);
         }
-        return _super.prototype._parseFunctionIdentifier.call(this);
-    };
-    LESSParser.prototype._parseURLArgument = function () {
-        var pos = this.mark();
-        var node = _super.prototype._parseURLArgument.call(this);
+        return super._parseFunctionIdentifier();
+    }
+    _parseURLArgument() {
+        const pos = this.mark();
+        const node = super._parseURLArgument();
         if (!node || !this.peek(TokenType.ParenthesisR)) {
             this.restoreAtMark(pos);
-            var node_2 = this.create(nodes.Node);
-            node_2.addChild(this._parseBinaryExpr());
-            return this.finish(node_2);
+            const node = this.create(nodes.Node);
+            node.addChild(this._parseBinaryExpr());
+            return this.finish(node);
         }
         return node;
-    };
-    return LESSParser;
-}(cssParser.Parser));
-export { LESSParser };
+    }
+}