vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/umd/parser/lessParser.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,37 +14,35 @@ var __extends = (this && this.__extends) || (function () {
     'use strict';
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.LESSParser = void 0;
-    var lessScanner = require("./lessScanner");
-    var cssScanner_1 = require("./cssScanner");
-    var cssParser = require("./cssParser");
-    var nodes = require("./cssNodes");
-    var cssErrors_1 = require("./cssErrors");
+    const lessScanner = require("./lessScanner");
+    const cssScanner_1 = require("./cssScanner");
+    const cssParser = require("./cssParser");
+    const nodes = require("./cssNodes");
+    const cssErrors_1 = require("./cssErrors");
     /// <summary>
     /// 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;
+    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(cssScanner_1.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(cssScanner_1.TokenType.ParenthesisL)) {
@@ -82,12 +65,12 @@ var __extends = (this && this.__extends) || (function () {
                 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, cssErrors_1.ParseError.StringLiteralExpected);
@@ -96,34 +79,32 @@ var __extends = (this && this.__extends) || (function () {
                 return this.finish(node, cssErrors_1.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;
             }
@@ -147,14 +128,14 @@ var __extends = (this && this.__extends) || (function () {
                 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(cssScanner_1.TokenType.ParenthesisL)) {
-                    var node = this.create(nodes.MixinDeclaration);
+                    let node = this.create(nodes.MixinDeclaration);
                     if (node.getParameters().addChild(this._parseMixinParameter())) {
                         while (this.accept(cssScanner_1.TokenType.Comma) || this.accept(cssScanner_1.TokenType.SemiColon)) {
                             if (this.peek(cssScanner_1.TokenType.ParenthesisR)) {
@@ -178,18 +159,18 @@ var __extends = (this && this.__extends) || (function () {
             if (!this.peek(cssScanner_1.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(cssScanner_1.TokenType.BracketL)) {
                     expectsValue = true;
@@ -200,10 +181,10 @@ var __extends = (this && this.__extends) || (function () {
                 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(cssScanner_1.TokenType.BracketL)) {
                 this.restoreAtMark(mark);
                 return null;
@@ -215,16 +196,14 @@ var __extends = (this && this.__extends) || (function () {
             }
             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(cssScanner_1.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);
@@ -242,22 +221,22 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             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(cssScanner_1.TokenType.EscapedJavaScript) ||
                 this.peek(cssScanner_1.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(cssScanner_1.TokenType.String) || this.accept(cssScanner_1.TokenType.EscapedJavaScript)) {
                     return this.finish(node);
@@ -267,75 +246,76 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             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(cssScanner_1.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(cssScanner_1.TokenType.CurlyL)) {
                     break;
                 }
@@ -343,10 +323,10 @@ var __extends = (this && this.__extends) || (function () {
                 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(cssScanner_1.TokenType.Num) || this.accept(cssScanner_1.TokenType.Dimension) || node.addChild(this._parseIdent()) || this.acceptDelim('&'))) {
                     //  support &-foo
@@ -354,25 +334,24 @@ var __extends = (this && this.__extends) || (function () {
                 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);
@@ -400,32 +379,31 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             return this.finish(node);
-        };
-        LESSParser.prototype.peekInterpolatedIdent = function () {
+        }
+        peekInterpolatedIdent() {
             return this.peek(cssScanner_1.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(cssScanner_1.TokenType.Ident); };
+            const accept = identRegex ?
+                () => this.acceptRegexp(identRegex) :
+                () => this.accept(cssScanner_1.TokenType.Ident);
             while (accept() ||
                 node.addChild(this._parseInterpolation() ||
                     this.try(indentInterpolation))) {
@@ -435,13 +413,13 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             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(cssScanner_1.TokenType.CurlyL)) {
                     this.restoreAtMark(mark);
@@ -456,10 +434,10 @@ var __extends = (this && this.__extends) || (function () {
                 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(cssScanner_1.TokenType.ParenthesisL)) {
                 this.restoreAtMark(mark);
                 return null;
@@ -484,12 +462,12 @@ var __extends = (this && this.__extends) || (function () {
                 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 .
@@ -506,38 +484,38 @@ var __extends = (this && this.__extends) || (function () {
             }
             identifier.referenceTypes = [nodes.ReferenceType.Mixin];
             return this.finish(identifier);
-        };
-        LESSParser.prototype._parsePseudo = function () {
+        }
+        _parsePseudo() {
             if (!this.peek(cssScanner_1.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(cssScanner_1.TokenType.Colon) || !this.acceptIdent('extend')) {
                 this.restoreAtMark(mark);
                 return null;
             }
             return this._completeExtends(node);
-        };
-        LESSParser.prototype._completeExtends = function (node) {
+        }
+        _completeExtends(node) {
             if (!this.accept(cssScanner_1.TokenType.ParenthesisL)) {
                 return this.finish(node, cssErrors_1.ParseError.LeftParenthesisExpected);
             }
-            var selectors = node.getSelectors();
+            const selectors = node.getSelectors();
             if (!selectors.addChild(this._parseSelector(true))) {
                 return this.finish(node, cssErrors_1.ParseError.SelectorExpected);
             }
@@ -550,13 +528,13 @@ var __extends = (this && this.__extends) || (function () {
                 return this.finish(node, cssErrors_1.ParseError.RightParenthesisExpected);
             }
             return this.finish(node);
-        };
-        LESSParser.prototype._parseDetachedRuleSetMixin = function () {
+        }
+        _parseDetachedRuleSetMixin() {
             if (!this.peek(cssScanner_1.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(cssScanner_1.TokenType.ParenthesisL))) {
                 this.restoreAtMark(mark);
                 return null;
@@ -565,15 +543,14 @@ var __extends = (this && this.__extends) || (function () {
                 return this.finish(node, cssErrors_1.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;
@@ -586,7 +563,7 @@ var __extends = (this && this.__extends) || (function () {
                 this.restoreAtMark(mark);
                 return null;
             }
-            var hasArguments = false;
+            let hasArguments = false;
             if (this.accept(cssScanner_1.TokenType.ParenthesisL)) {
                 hasArguments = true;
                 if (node.getArguments().addChild(this._parseMixinArgument())) {
@@ -620,12 +597,12 @@ var __extends = (this && this.__extends) || (function () {
                 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(cssScanner_1.TokenType.Colon)) {
                     this.restoreAtMark(pos);
@@ -639,12 +616,12 @@ var __extends = (this && this.__extends) || (function () {
             }
             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, cssErrors_1.ParseError.DotExpected, [], [cssScanner_1.TokenType.Comma, cssScanner_1.TokenType.ParenthesisR]);
@@ -654,12 +631,12 @@ var __extends = (this && this.__extends) || (function () {
             }
             // 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(cssScanner_1.TokenType.Colon);
@@ -669,12 +646,12 @@ var __extends = (this && this.__extends) || (function () {
                 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())) {
@@ -686,12 +663,12 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             return this.finish(node);
-        };
-        LESSParser.prototype._parseGuardCondition = function () {
+        }
+        _parseGuardCondition() {
             if (!this.peek(cssScanner_1.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 (?)
@@ -700,10 +677,10 @@ var __extends = (this && this.__extends) || (function () {
                 return this.finish(node, cssErrors_1.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;
             }
@@ -725,28 +702,27 @@ var __extends = (this && this.__extends) || (function () {
                 return this.finish(node, cssErrors_1.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(cssScanner_1.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));
+        }
+    }
     exports.LESSParser = LESSParser;
 });