vscode-css-languageservice 5.4.2 → 6.1.0

package/lib/esm/parser/cssParser.js

@@ -3,15 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 'use strict';
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { TokenType, Scanner } from './cssScanner';
 import * as nodes from './cssNodes';
 import { ParseError } from './cssErrors';
@@ -22,80 +13,74 @@ import { isDefined } from '../utils/objects';
 /// https://www.w3.org/TR/CSS21/grammar.html
 /// http://www.w3.org/TR/CSS21/syndata.html#tokenization
 /// </summary>
-var Parser = /** @class */ (function () {
-    function Parser(scnr) {
-        if (scnr === void 0) { scnr = new Scanner(); }
+export class Parser {
+    constructor(scnr = new Scanner()) {
         this.keyframeRegex = /^@(\-(webkit|ms|moz|o)\-)?keyframes$/i;
         this.scanner = scnr;
         this.token = { type: TokenType.EOF, offset: -1, len: 0, text: '' };
         this.prevToken = undefined;
     }
-    Parser.prototype.peekIdent = function (text) {
+    peekIdent(text) {
         return TokenType.Ident === this.token.type && text.length === this.token.text.length && text === this.token.text.toLowerCase();
-    };
-    Parser.prototype.peekKeyword = function (text) {
+    }
+    peekKeyword(text) {
         return TokenType.AtKeyword === this.token.type && text.length === this.token.text.length && text === this.token.text.toLowerCase();
-    };
-    Parser.prototype.peekDelim = function (text) {
+    }
+    peekDelim(text) {
         return TokenType.Delim === this.token.type && text === this.token.text;
-    };
-    Parser.prototype.peek = function (type) {
+    }
+    peek(type) {
         return type === this.token.type;
-    };
-    Parser.prototype.peekOne = function () {
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
-        }
+    }
+    peekOne(...types) {
         return types.indexOf(this.token.type) !== -1;
-    };
-    Parser.prototype.peekRegExp = function (type, regEx) {
+    }
+    peekRegExp(type, regEx) {
         if (type !== this.token.type) {
             return false;
         }
         return regEx.test(this.token.text);
-    };
-    Parser.prototype.hasWhitespace = function () {
+    }
+    hasWhitespace() {
         return !!this.prevToken && (this.prevToken.offset + this.prevToken.len !== this.token.offset);
-    };
-    Parser.prototype.consumeToken = function () {
+    }
+    consumeToken() {
         this.prevToken = this.token;
         this.token = this.scanner.scan();
-    };
-    Parser.prototype.acceptUnicodeRange = function () {
-        var token = this.scanner.tryScanUnicode();
+    }
+    acceptUnicodeRange() {
+        const token = this.scanner.tryScanUnicode();
         if (token) {
             this.prevToken = token;
             this.token = this.scanner.scan();
             return true;
         }
         return false;
-    };
-    Parser.prototype.mark = function () {
+    }
+    mark() {
         return {
             prev: this.prevToken,
             curr: this.token,
             pos: this.scanner.pos()
         };
-    };
-    Parser.prototype.restoreAtMark = function (mark) {
+    }
+    restoreAtMark(mark) {
         this.prevToken = mark.prev;
         this.token = mark.curr;
         this.scanner.goBackTo(mark.pos);
-    };
-    Parser.prototype.try = function (func) {
-        var pos = this.mark();
-        var node = func();
+    }
+    try(func) {
+        const pos = this.mark();
+        const node = func();
         if (!node) {
             this.restoreAtMark(pos);
             return null;
         }
         return node;
-    };
-    Parser.prototype.acceptOneKeyword = function (keywords) {
+    }
+    acceptOneKeyword(keywords) {
         if (TokenType.AtKeyword === this.token.type) {
-            for (var _i = 0, keywords_1 = keywords; _i < keywords_1.length; _i++) {
-                var keyword = keywords_1[_i];
+            for (const keyword of keywords) {
                 if (keyword.length === this.token.text.length && keyword === this.token.text.toLowerCase()) {
                     this.consumeToken();
                     return true;
@@ -103,51 +88,51 @@ var Parser = /** @class */ (function () {
             }
         }
         return false;
-    };
-    Parser.prototype.accept = function (type) {
+    }
+    accept(type) {
         if (type === this.token.type) {
             this.consumeToken();
             return true;
         }
         return false;
-    };
-    Parser.prototype.acceptIdent = function (text) {
+    }
+    acceptIdent(text) {
         if (this.peekIdent(text)) {
             this.consumeToken();
             return true;
         }
         return false;
-    };
-    Parser.prototype.acceptKeyword = function (text) {
+    }
+    acceptKeyword(text) {
         if (this.peekKeyword(text)) {
             this.consumeToken();
             return true;
         }
         return false;
-    };
-    Parser.prototype.acceptDelim = function (text) {
+    }
+    acceptDelim(text) {
         if (this.peekDelim(text)) {
             this.consumeToken();
             return true;
         }
         return false;
-    };
-    Parser.prototype.acceptRegexp = function (regEx) {
+    }
+    acceptRegexp(regEx) {
         if (regEx.test(this.token.text)) {
             this.consumeToken();
             return true;
         }
         return false;
-    };
-    Parser.prototype._parseRegexp = function (regEx) {
-        var node = this.createNode(nodes.NodeType.Identifier);
+    }
+    _parseRegexp(regEx) {
+        let node = this.createNode(nodes.NodeType.Identifier);
         do { } while (this.acceptRegexp(regEx));
         return this.finish(node);
-    };
-    Parser.prototype.acceptUnquotedString = function () {
-        var pos = this.scanner.pos();
+    }
+    acceptUnquotedString() {
+        const pos = this.scanner.pos();
         this.scanner.goBackTo(this.token.offset);
-        var unquoted = this.scanner.scanUnquotedString();
+        const unquoted = this.scanner.scanUnquotedString();
         if (unquoted) {
             this.token = unquoted;
             this.consumeToken();
@@ -155,8 +140,8 @@ var Parser = /** @class */ (function () {
         }
         this.scanner.goBackTo(pos);
         return false;
-    };
-    Parser.prototype.resync = function (resyncTokens, resyncStopTokens) {
+    }
+    resync(resyncTokens, resyncStopTokens) {
         while (true) {
             if (resyncTokens && resyncTokens.indexOf(this.token.type) !== -1) {
                 this.consumeToken();
@@ -172,14 +157,14 @@ var Parser = /** @class */ (function () {
                 this.token = this.scanner.scan();
             }
         }
-    };
-    Parser.prototype.createNode = function (nodeType) {
+    }
+    createNode(nodeType) {
         return new nodes.Node(this.token.offset, this.token.len, nodeType);
-    };
-    Parser.prototype.create = function (ctor) {
+    }
+    create(ctor) {
         return new ctor(this.token.offset, this.token.len);
-    };
-    Parser.prototype.finish = function (node, error, resyncTokens, resyncStopTokens) {
+    }
+    finish(node, error, resyncTokens, resyncStopTokens) {
         // parseNumeric misuses error for boolean flagging (however the real error mustn't be a false)
         // + nodelist offsets mustn't be modified, because there is a offset hack in rulesets for smartselection
         if (!(node instanceof nodes.Nodelist)) {
@@ -189,13 +174,13 @@ var Parser = /** @class */ (function () {
             // set the node end position
             if (this.prevToken) {
                 // length with more elements belonging together
-                var prevEnd = this.prevToken.offset + this.prevToken.len;
+                const prevEnd = this.prevToken.offset + this.prevToken.len;
                 node.length = prevEnd > node.offset ? prevEnd - node.offset : 0; // offset is taken from current token, end from previous: Use 0 for empty nodes
             }
         }
         return node;
-    };
-    Parser.prototype.markError = function (node, error, resyncTokens, resyncStopTokens) {
+    }
+    markError(node, error, resyncTokens, resyncStopTokens) {
         if (this.token !== this.lastErrorToken) { // do not report twice on the same token
             node.addIssue(new nodes.Marker(node, error, nodes.Level.Error, undefined, this.token.offset, this.token.len));
             this.lastErrorToken = this.token;
@@ -203,43 +188,43 @@ var Parser = /** @class */ (function () {
         if (resyncTokens || resyncStopTokens) {
             this.resync(resyncTokens, resyncStopTokens);
         }
-    };
-    Parser.prototype.parseStylesheet = function (textDocument) {
-        var versionId = textDocument.version;
-        var text = textDocument.getText();
-        var textProvider = function (offset, length) {
+    }
+    parseStylesheet(textDocument) {
+        const versionId = textDocument.version;
+        const text = textDocument.getText();
+        const textProvider = (offset, length) => {
             if (textDocument.version !== versionId) {
                 throw new Error('Underlying model has changed, AST is no longer valid');
             }
             return text.substr(offset, length);
         };
         return this.internalParse(text, this._parseStylesheet, textProvider);
-    };
-    Parser.prototype.internalParse = function (input, parseFunc, textProvider) {
+    }
+    internalParse(input, parseFunc, textProvider) {
         this.scanner.setSource(input);
         this.token = this.scanner.scan();
-        var node = parseFunc.bind(this)();
+        const node = parseFunc.bind(this)();
         if (node) {
             if (textProvider) {
                 node.textProvider = textProvider;
             }
             else {
-                node.textProvider = function (offset, length) { return input.substr(offset, length); };
+                node.textProvider = (offset, length) => { return input.substr(offset, length); };
             }
         }
         return node;
-    };
-    Parser.prototype._parseStylesheet = function () {
-        var node = this.create(nodes.Stylesheet);
+    }
+    _parseStylesheet() {
+        const node = this.create(nodes.Stylesheet);
         while (node.addChild(this._parseStylesheetStart())) {
             // Parse statements only valid at the beginning of stylesheets.
         }
-        var inRecovery = false;
+        let inRecovery = false;
         do {
-            var hasMatch = false;
+            let hasMatch = false;
             do {
                 hasMatch = false;
-                var statement = this._parseStylesheetStatement();
+                const statement = this._parseStylesheetStatement();
                 if (statement) {
                     node.addChild(statement);
                     hasMatch = true;
@@ -269,32 +254,31 @@ var Parser = /** @class */ (function () {
             this.consumeToken();
         } while (!this.peek(TokenType.EOF));
         return this.finish(node);
-    };
-    Parser.prototype._parseStylesheetStart = function () {
+    }
+    _parseStylesheetStart() {
         return this._parseCharset();
-    };
-    Parser.prototype._parseStylesheetStatement = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseStylesheetStatement(isNested = false) {
         if (this.peek(TokenType.AtKeyword)) {
             return this._parseStylesheetAtStatement(isNested);
         }
         return this._parseRuleset(isNested);
-    };
-    Parser.prototype._parseStylesheetAtStatement = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseStylesheetAtStatement(isNested = false) {
         return this._parseImport()
             || this._parseMedia(isNested)
             || this._parsePage()
             || this._parseFontFace()
             || this._parseKeyframe()
             || this._parseSupports(isNested)
+            || this._parseLayer()
             || this._parseViewPort()
             || this._parseNamespace()
             || this._parseDocument()
             || this._parseUnknownAtRule();
-    };
-    Parser.prototype._tryParseRuleset = function (isNested) {
-        var mark = this.mark();
+    }
+    _tryParseRuleset(isNested) {
+        const mark = this.mark();
         if (this._parseSelector(isNested)) {
             while (this.accept(TokenType.Comma) && this._parseSelector(isNested)) {
                 // loop
@@ -306,11 +290,10 @@ var Parser = /** @class */ (function () {
         }
         this.restoreAtMark(mark);
         return null;
-    };
-    Parser.prototype._parseRuleset = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
-        var node = this.create(nodes.RuleSet);
-        var selectors = node.getSelectors();
+    }
+    _parseRuleset(isNested = false) {
+        const node = this.create(nodes.RuleSet);
+        const selectors = node.getSelectors();
         if (!selectors.addChild(this._parseSelector(isNested))) {
             return null;
         }
@@ -320,18 +303,18 @@ var Parser = /** @class */ (function () {
             }
         }
         return this._parseBody(node, this._parseRuleSetDeclaration.bind(this));
-    };
-    Parser.prototype._parseRuleSetDeclarationAtStatement = function () {
+    }
+    _parseRuleSetDeclarationAtStatement() {
         return this._parseUnknownAtRule();
-    };
-    Parser.prototype._parseRuleSetDeclaration = function () {
+    }
+    _parseRuleSetDeclaration() {
         // https://www.w3.org/TR/css-syntax-3/#consume-a-list-of-declarations
         if (this.peek(TokenType.AtKeyword)) {
             return this._parseRuleSetDeclarationAtStatement();
         }
         return this._parseDeclaration();
-    };
-    Parser.prototype._needsSemicolonAfter = function (node) {
+    }
+    _needsSemicolonAfter(node) {
         switch (node.type) {
             case nodes.NodeType.Keyframe:
             case nodes.NodeType.ViewPort:
@@ -363,13 +346,13 @@ var Parser = /** @class */ (function () {
                 return !node.getNestedProperties();
         }
         return false;
-    };
-    Parser.prototype._parseDeclarations = function (parseDeclaration) {
-        var node = this.create(nodes.Declarations);
+    }
+    _parseDeclarations(parseDeclaration) {
+        const node = this.create(nodes.Declarations);
         if (!this.accept(TokenType.CurlyL)) {
             return null;
         }
-        var decl = parseDeclaration();
+        let decl = parseDeclaration();
         while (node.addChild(decl)) {
             if (this.peek(TokenType.CurlyR)) {
                 break;
@@ -390,16 +373,16 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.RightCurlyExpected, [TokenType.CurlyR, TokenType.SemiColon]);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseBody = function (node, parseDeclaration) {
+    }
+    _parseBody(node, parseDeclaration) {
         if (!node.setDeclarations(this._parseDeclarations(parseDeclaration))) {
             return this.finish(node, ParseError.LeftCurlyExpected, [TokenType.CurlyR, TokenType.SemiColon]);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseSelector = function (isNested) {
-        var node = this.create(nodes.Selector);
-        var hasContent = false;
+    }
+    _parseSelector(isNested) {
+        const node = this.create(nodes.Selector);
+        let hasContent = false;
         if (isNested) {
             // nested selectors can start with a combinator
             hasContent = node.addChild(this._parseCombinator());
@@ -409,13 +392,13 @@ var Parser = /** @class */ (function () {
             node.addChild(this._parseCombinator()); // optional
         }
         return hasContent ? this.finish(node) : null;
-    };
-    Parser.prototype._parseDeclaration = function (stopTokens) {
-        var custonProperty = this._tryParseCustomPropertyDeclaration(stopTokens);
+    }
+    _parseDeclaration(stopTokens) {
+        const custonProperty = this._tryParseCustomPropertyDeclaration(stopTokens);
         if (custonProperty) {
             return custonProperty;
         }
-        var node = this.create(nodes.Declaration);
+        const node = this.create(nodes.Declaration);
         if (!node.setProperty(this._parseProperty())) {
             return null;
         }
@@ -433,12 +416,12 @@ var Parser = /** @class */ (function () {
             node.semicolonPosition = this.token.offset; // not part of the declaration, but useful information for code assist
         }
         return this.finish(node);
-    };
-    Parser.prototype._tryParseCustomPropertyDeclaration = function (stopTokens) {
+    }
+    _tryParseCustomPropertyDeclaration(stopTokens) {
         if (!this.peekRegExp(TokenType.Ident, /^--/)) {
             return null;
         }
-        var node = this.create(nodes.CustomPropertyDeclaration);
+        const node = this.create(nodes.CustomPropertyDeclaration);
         if (!node.setProperty(this._parseProperty())) {
             return null;
         }
@@ -448,11 +431,11 @@ var Parser = /** @class */ (function () {
         if (this.prevToken) {
             node.colonPosition = this.prevToken.offset;
         }
-        var mark = this.mark();
+        const mark = this.mark();
         if (this.peek(TokenType.CurlyL)) {
             // try to parse it as nested declaration
-            var propertySet = this.create(nodes.CustomPropertySet);
-            var declarations = this._parseDeclarations(this._parseRuleSetDeclaration.bind(this));
+            const propertySet = this.create(nodes.CustomPropertySet);
+            const declarations = this._parseDeclarations(this._parseRuleSetDeclaration.bind(this));
             if (propertySet.setDeclarations(declarations) && !declarations.isErroneous(true)) {
                 propertySet.addChild(this._parsePrio());
                 if (this.peek(TokenType.SemiColon)) {
@@ -465,10 +448,10 @@ var Parser = /** @class */ (function () {
             this.restoreAtMark(mark);
         }
         // try to parse as expression
-        var expression = this._parseExpr();
+        const expression = this._parseExpr();
         if (expression && !expression.isErroneous(true)) {
             this._parsePrio();
-            if (this.peekOne.apply(this, __spreadArray(__spreadArray([], (stopTokens || []), false), [TokenType.SemiColon, TokenType.EOF], false))) {
+            if (this.peekOne(...(stopTokens || []), TokenType.SemiColon, TokenType.EOF)) {
                 node.setValue(expression);
                 if (this.peek(TokenType.SemiColon)) {
                     node.semicolonPosition = this.token.offset; // not part of the declaration, but useful information for code assist
@@ -483,7 +466,7 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.PropertyValueExpected);
         }
         return this.finish(node);
-    };
+    }
     /**
      * Parse custom property values.
      *
@@ -495,15 +478,13 @@ var Parser = /** @class */ (function () {
      * terminators like semicolons and !important directives (when not inside
      * of delimitors).
      */
-    Parser.prototype._parseCustomPropertyValue = function (stopTokens) {
-        var _this = this;
-        if (stopTokens === void 0) { stopTokens = [TokenType.CurlyR]; }
-        var node = this.create(nodes.Node);
-        var isTopLevel = function () { return curlyDepth === 0 && parensDepth === 0 && bracketsDepth === 0; };
-        var onStopToken = function () { return stopTokens.indexOf(_this.token.type) !== -1; };
-        var curlyDepth = 0;
-        var parensDepth = 0;
-        var bracketsDepth = 0;
+    _parseCustomPropertyValue(stopTokens = [TokenType.CurlyR]) {
+        const node = this.create(nodes.Node);
+        const isTopLevel = () => curlyDepth === 0 && parensDepth === 0 && bracketsDepth === 0;
+        const onStopToken = () => stopTokens.indexOf(this.token.type) !== -1;
+        let curlyDepth = 0;
+        let parensDepth = 0;
+        let bracketsDepth = 0;
         done: while (true) {
             switch (this.token.type) {
                 case TokenType.SemiColon:
@@ -558,7 +539,7 @@ var Parser = /** @class */ (function () {
                 case TokenType.EOF:
                     // We shouldn't have reached the end of input, something is
                     // unterminated.
-                    var error = ParseError.RightCurlyExpected;
+                    let error = ParseError.RightCurlyExpected;
                     if (bracketsDepth > 0) {
                         error = ParseError.RightSquareBracketExpected;
                     }
@@ -570,9 +551,9 @@ var Parser = /** @class */ (function () {
             this.consumeToken();
         }
         return this.finish(node);
-    };
-    Parser.prototype._tryToParseDeclaration = function (stopTokens) {
-        var mark = this.mark();
+    }
+    _tryToParseDeclaration(stopTokens) {
+        const mark = this.mark();
         if (this._parseProperty() && this.accept(TokenType.Colon)) {
             // looks like a declaration, go ahead
             this.restoreAtMark(mark);
@@ -580,10 +561,10 @@ var Parser = /** @class */ (function () {
         }
         this.restoreAtMark(mark);
         return null;
-    };
-    Parser.prototype._parseProperty = function () {
-        var node = this.create(nodes.Property);
-        var mark = this.mark();
+    }
+    _parseProperty() {
+        const node = this.create(nodes.Property);
+        const mark = this.mark();
         if (this.acceptDelim('*') || this.acceptDelim('_')) {
             // support for  IE 5.x, 6 and 7 star hack: see http://en.wikipedia.org/wiki/CSS_filter#Star_hack
             if (this.hasWhitespace()) {
@@ -595,15 +576,15 @@ var Parser = /** @class */ (function () {
             return this.finish(node);
         }
         return null;
-    };
-    Parser.prototype._parsePropertyIdentifier = function () {
+    }
+    _parsePropertyIdentifier() {
         return this._parseIdent();
-    };
-    Parser.prototype._parseCharset = function () {
+    }
+    _parseCharset() {
         if (!this.peek(TokenType.Charset)) {
             return null;
         }
-        var node = this.create(nodes.Node);
+        const node = this.create(nodes.Node);
         this.consumeToken(); // charset
         if (!this.accept(TokenType.String)) {
             return this.finish(node, ParseError.IdentifierExpected);
@@ -612,28 +593,51 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.SemiColonExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseImport = function () {
+    }
+    _parseImport() {
+        // @import [ <url> | <string> ]
+        //     [ layer | layer(<layer-name>) ]?
+        //     <import-condition> ;
+        // <import-conditions> = [ supports( [ <supports-condition> | <declaration> ] ) ]?
+        //                      <media-query-list>?
         if (!this.peekKeyword('@import')) {
             return null;
         }
-        var node = this.create(nodes.Import);
+        const node = this.create(nodes.Import);
         this.consumeToken(); // @import
         if (!node.addChild(this._parseURILiteral()) && !node.addChild(this._parseStringLiteral())) {
             return this.finish(node, ParseError.URIOrStringExpected);
         }
+        if (this.acceptIdent('layer')) {
+            if (this.accept(TokenType.ParenthesisL)) {
+                if (!node.addChild(this._parseLayerName())) {
+                    return this.finish(node, ParseError.IdentifierExpected, [TokenType.SemiColon]);
+                }
+                if (!this.accept(TokenType.ParenthesisR)) {
+                    return this.finish(node, ParseError.RightParenthesisExpected, [TokenType.ParenthesisR], []);
+                }
+            }
+        }
+        if (this.acceptIdent('supports')) {
+            if (this.accept(TokenType.ParenthesisL)) {
+                node.addChild(this._tryToParseDeclaration() || this._parseSupportsCondition());
+                if (!this.accept(TokenType.ParenthesisR)) {
+                    return this.finish(node, ParseError.RightParenthesisExpected, [TokenType.ParenthesisR], []);
+                }
+            }
+        }
         if (!this.peek(TokenType.SemiColon) && !this.peek(TokenType.EOF)) {
             node.setMedialist(this._parseMediaQueryList());
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseNamespace = function () {
+    }
+    _parseNamespace() {
         // http://www.w3.org/TR/css3-namespace/
         // namespace  : NAMESPACE_SYM S* [IDENT S*]? [STRING|URI] S* ';' S*
         if (!this.peekKeyword('@namespace')) {
             return null;
         }
-        var node = this.create(nodes.Namespace);
+        const node = this.create(nodes.Namespace);
         this.consumeToken(); // @namespace
         if (!node.addChild(this._parseURILiteral())) { // url literal also starts with ident
             node.addChild(this._parseIdent()); // optional prefix
@@ -645,31 +649,31 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.SemiColonExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseFontFace = function () {
+    }
+    _parseFontFace() {
         if (!this.peekKeyword('@font-face')) {
             return null;
         }
-        var node = this.create(nodes.FontFace);
+        const node = this.create(nodes.FontFace);
         this.consumeToken(); // @font-face
         return this._parseBody(node, this._parseRuleSetDeclaration.bind(this));
-    };
-    Parser.prototype._parseViewPort = function () {
+    }
+    _parseViewPort() {
         if (!this.peekKeyword('@-ms-viewport') &&
             !this.peekKeyword('@-o-viewport') &&
             !this.peekKeyword('@viewport')) {
             return null;
         }
-        var node = this.create(nodes.ViewPort);
+        const node = this.create(nodes.ViewPort);
         this.consumeToken(); // @-ms-viewport
         return this._parseBody(node, this._parseRuleSetDeclaration.bind(this));
-    };
-    Parser.prototype._parseKeyframe = function () {
+    }
+    _parseKeyframe() {
         if (!this.peekRegExp(TokenType.AtKeyword, this.keyframeRegex)) {
             return null;
         }
-        var node = this.create(nodes.Keyframe);
-        var atNode = this.create(nodes.Node);
+        const node = this.create(nodes.Keyframe);
+        const atNode = this.create(nodes.Node);
         this.consumeToken(); // atkeyword
         node.setKeyword(this.finish(atNode));
         if (atNode.matches('@-ms-keyframes')) { // -ms-keyframes never existed
@@ -679,12 +683,12 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.IdentifierExpected, [TokenType.CurlyR]);
         }
         return this._parseBody(node, this._parseKeyframeSelector.bind(this));
-    };
-    Parser.prototype._parseKeyframeIdent = function () {
+    }
+    _parseKeyframeIdent() {
         return this._parseIdent([nodes.ReferenceType.Keyframe]);
-    };
-    Parser.prototype._parseKeyframeSelector = function () {
-        var node = this.create(nodes.KeyframeSelector);
+    }
+    _parseKeyframeSelector() {
+        const node = this.create(nodes.KeyframeSelector);
         if (!node.addChild(this._parseIdent()) && !this.accept(TokenType.Percentage)) {
             return null;
         }
@@ -694,10 +698,10 @@ var Parser = /** @class */ (function () {
             }
         }
         return this._parseBody(node, this._parseRuleSetDeclaration.bind(this));
-    };
-    Parser.prototype._tryParseKeyframeSelector = function () {
-        var node = this.create(nodes.KeyframeSelector);
-        var pos = this.mark();
+    }
+    _tryParseKeyframeSelector() {
+        const node = this.create(nodes.KeyframeSelector);
+        const pos = this.mark();
         if (!node.addChild(this._parseIdent()) && !this.accept(TokenType.Percentage)) {
             return null;
         }
@@ -712,20 +716,66 @@ var Parser = /** @class */ (function () {
             return null;
         }
         return this._parseBody(node, this._parseRuleSetDeclaration.bind(this));
-    };
-    Parser.prototype._parseSupports = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseLayer() {
+        // @layer layer-name {rules}
+        // @layer layer-name;
+        // @layer layer-name, layer-name, layer-name;
+        // @layer {rules}
+        if (!this.peekKeyword('@layer')) {
+            return null;
+        }
+        const node = this.create(nodes.Layer);
+        this.consumeToken(); // @layer
+        const names = this._parseLayerNameList();
+        if (names) {
+            node.setNames(names);
+        }
+        if ((!names || names.getChildren().length === 1) && this.peek(TokenType.CurlyL)) {
+            return this._parseBody(node, this._parseStylesheetStatement.bind(this));
+        }
+        if (!this.accept(TokenType.SemiColon)) {
+            return this.finish(node, ParseError.SemiColonExpected);
+        }
+        return this.finish(node);
+    }
+    _parseLayerNameList() {
+        const node = this.createNode(nodes.NodeType.LayerNameList);
+        if (!node.addChild(this._parseLayerName())) {
+            return null;
+        }
+        while (this.accept(TokenType.Comma)) {
+            if (!node.addChild(this._parseLayerName())) {
+                return this.finish(node, ParseError.IdentifierExpected);
+            }
+        }
+        return this.finish(node);
+    }
+    _parseLayerName() {
+        // <layer-name> = <ident> [ '.' <ident> ]*
+        if (!this.peek(TokenType.Ident)) {
+            return null;
+        }
+        const node = this.createNode(nodes.NodeType.LayerName);
+        node.addChild(this._parseIdent());
+        while (!this.hasWhitespace() && this.acceptDelim('.')) {
+            if (this.hasWhitespace() || !node.addChild(this._parseIdent())) {
+                return this.finish(node, ParseError.IdentifierExpected);
+            }
+        }
+        return this.finish(node);
+    }
+    _parseSupports(isNested = false) {
         // SUPPORTS_SYM S* supports_condition '{' S* ruleset* '}' S*
         if (!this.peekKeyword('@supports')) {
             return null;
         }
-        var node = this.create(nodes.Supports);
+        const node = this.create(nodes.Supports);
         this.consumeToken(); // @supports
         node.addChild(this._parseSupportsCondition());
         return this._parseBody(node, this._parseSupportsDeclaration.bind(this, isNested));
-    };
-    Parser.prototype._parseSupportsDeclaration = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseSupportsDeclaration(isNested = false) {
         if (isNested) {
             // if nested, the body can contain rulesets, but also declarations
             return this._tryParseRuleset(true)
@@ -733,8 +783,8 @@ var Parser = /** @class */ (function () {
                 || this._parseStylesheetStatement(true);
         }
         return this._parseStylesheetStatement(false);
-    };
-    Parser.prototype._parseSupportsCondition = function () {
+    }
+    _parseSupportsCondition() {
         // supports_condition : supports_negation | supports_conjunction | supports_disjunction | supports_condition_in_parens ;
         // supports_condition_in_parens: ( '(' S* supports_condition S* ')' ) | supports_declaration_condition | general_enclosed ;
         // supports_negation: NOT S+ supports_condition_in_parens ;
@@ -742,23 +792,23 @@ var Parser = /** @class */ (function () {
         // supports_disjunction: supports_condition_in_parens ( S+ OR S+ supports_condition_in_parens )+;
         // supports_declaration_condition: '(' S* declaration ')';
         // general_enclosed: ( FUNCTION | '(' ) ( any | unused )* ')' ;
-        var node = this.create(nodes.SupportsCondition);
+        const node = this.create(nodes.SupportsCondition);
         if (this.acceptIdent('not')) {
             node.addChild(this._parseSupportsConditionInParens());
         }
         else {
             node.addChild(this._parseSupportsConditionInParens());
             if (this.peekRegExp(TokenType.Ident, /^(and|or)$/i)) {
-                var text = this.token.text.toLowerCase();
+                const text = this.token.text.toLowerCase();
                 while (this.acceptIdent(text)) {
                     node.addChild(this._parseSupportsConditionInParens());
                 }
             }
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseSupportsConditionInParens = function () {
-        var node = this.create(nodes.SupportsCondition);
+    }
+    _parseSupportsConditionInParens() {
+        const node = this.create(nodes.SupportsCondition);
         if (this.accept(TokenType.ParenthesisL)) {
             if (this.prevToken) {
                 node.lParent = this.prevToken.offset;
@@ -777,10 +827,10 @@ var Parser = /** @class */ (function () {
             return this.finish(node);
         }
         else if (this.peek(TokenType.Ident)) {
-            var pos = this.mark();
+            const pos = this.mark();
             this.consumeToken();
             if (!this.hasWhitespace() && this.accept(TokenType.ParenthesisL)) {
-                var openParentCount = 1;
+                let openParentCount = 1;
                 while (this.token.type !== TokenType.EOF && openParentCount !== 0) {
                     if (this.token.type === TokenType.ParenthesisL) {
                         openParentCount++;
@@ -797,9 +847,8 @@ var Parser = /** @class */ (function () {
             }
         }
         return this.finish(node, ParseError.LeftParenthesisExpected, [], [TokenType.ParenthesisL]);
-    };
-    Parser.prototype._parseMediaDeclaration = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseMediaDeclaration(isNested = false) {
         if (isNested) {
             // if nested, the body can contain rulesets, but also declarations
             return this._tryParseRuleset(true)
@@ -807,23 +856,22 @@ var Parser = /** @class */ (function () {
                 || this._parseStylesheetStatement(true);
         }
         return this._parseStylesheetStatement(false);
-    };
-    Parser.prototype._parseMedia = function (isNested) {
-        if (isNested === void 0) { isNested = false; }
+    }
+    _parseMedia(isNested = false) {
         // MEDIA_SYM S* media_query_list '{' S* ruleset* '}' S*
         // media_query_list : S* [media_query [ ',' S* media_query ]* ]?
         if (!this.peekKeyword('@media')) {
             return null;
         }
-        var node = this.create(nodes.Media);
+        const node = this.create(nodes.Media);
         this.consumeToken(); // @media
         if (!node.addChild(this._parseMediaQueryList())) {
             return this.finish(node, ParseError.MediaQueryExpected);
         }
         return this._parseBody(node, this._parseMediaDeclaration.bind(this, isNested));
-    };
-    Parser.prototype._parseMediaQueryList = function () {
-        var node = this.create(nodes.Medialist);
+    }
+    _parseMediaQueryList() {
+        const node = this.create(nodes.Medialist);
         if (!node.addChild(this._parseMediaQuery())) {
             return this.finish(node, ParseError.MediaQueryExpected);
         }
@@ -833,11 +881,11 @@ var Parser = /** @class */ (function () {
             }
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseMediaQuery = function () {
+    }
+    _parseMediaQuery() {
         // <media-query> = <media-condition> | [ not | only ]? <media-type> [ and <media-condition-without-or> ]?
-        var node = this.create(nodes.MediaQuery);
-        var pos = this.mark();
+        const node = this.create(nodes.MediaQuery);
+        const pos = this.mark();
         this.acceptIdent('not');
         if (!this.peek(TokenType.ParenthesisL)) {
             if (this.acceptIdent('only')) {
@@ -855,10 +903,10 @@ var Parser = /** @class */ (function () {
             node.addChild(this._parseMediaCondition());
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseRatio = function () {
-        var pos = this.mark();
-        var node = this.create(nodes.RatioValue);
+    }
+    _parseRatio() {
+        const pos = this.mark();
+        const node = this.create(nodes.RatioValue);
         if (!this._parseNumeric()) {
             return null;
         }
@@ -870,16 +918,16 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.NumberExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseMediaCondition = function () {
+    }
+    _parseMediaCondition() {
         // <media-condition> = <media-not> | <media-and> | <media-or> | <media-in-parens>
         // <media-not> = not <media-in-parens>
         // <media-and> = <media-in-parens> [ and <media-in-parens> ]+
         // <media-or> = <media-in-parens> [ or <media-in-parens> ]+
         // <media-in-parens> = ( <media-condition> ) | <media-feature> | <general-enclosed>
-        var node = this.create(nodes.MediaCondition);
+        const node = this.create(nodes.MediaCondition);
         this.acceptIdent('not');
-        var parseExpression = true;
+        let parseExpression = true;
         while (parseExpression) {
             if (!this.accept(TokenType.ParenthesisL)) {
                 return this.finish(node, ParseError.LeftParenthesisExpected, [], [TokenType.CurlyL]);
@@ -898,23 +946,22 @@ var Parser = /** @class */ (function () {
             parseExpression = this.acceptIdent('and') || this.acceptIdent('or');
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseMediaFeature = function () {
-        var _this = this;
-        var resyncStopToken = [TokenType.ParenthesisR];
-        var node = this.create(nodes.MediaFeature);
+    }
+    _parseMediaFeature() {
+        const resyncStopToken = [TokenType.ParenthesisR];
+        const node = this.create(nodes.MediaFeature);
         // <media-feature> = ( [ <mf-plain> | <mf-boolean> | <mf-range> ] )
         // <mf-plain> = <mf-name> : <mf-value>
         // <mf-boolean> = <mf-name>
         // <mf-range> = <mf-name> [ '<' | '>' ]? '='? <mf-value> | <mf-value> [ '<' | '>' ]? '='? <mf-name> | <mf-value> '<' '='? <mf-name> '<' '='? <mf-value> | <mf-value> '>' '='? <mf-name> '>' '='? <mf-value>
-        var parseRangeOperator = function () {
-            if (_this.acceptDelim('<') || _this.acceptDelim('>')) {
-                if (!_this.hasWhitespace()) {
-                    _this.acceptDelim('=');
+        const parseRangeOperator = () => {
+            if (this.acceptDelim('<') || this.acceptDelim('>')) {
+                if (!this.hasWhitespace()) {
+                    this.acceptDelim('=');
                 }
                 return true;
             }
-            else if (_this.acceptDelim('=')) {
+            else if (this.acceptDelim('=')) {
                 return true;
             }
             return false;
@@ -956,33 +1003,33 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.IdentifierExpected, [], resyncStopToken);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseMediaFeatureName = function () {
+    }
+    _parseMediaFeatureName() {
         return this._parseIdent();
-    };
-    Parser.prototype._parseMediaFeatureValue = function () {
+    }
+    _parseMediaFeatureValue() {
         return this._parseRatio() || this._parseTermExpression();
-    };
-    Parser.prototype._parseMedium = function () {
-        var node = this.create(nodes.Node);
+    }
+    _parseMedium() {
+        const node = this.create(nodes.Node);
         if (node.addChild(this._parseIdent())) {
             return this.finish(node);
         }
         else {
             return null;
         }
-    };
-    Parser.prototype._parsePageDeclaration = function () {
+    }
+    _parsePageDeclaration() {
         return this._parsePageMarginBox() || this._parseRuleSetDeclaration();
-    };
-    Parser.prototype._parsePage = function () {
+    }
+    _parsePage() {
         // http://www.w3.org/TR/css3-page/
         // page_rule : PAGE_SYM S* page_selector_list '{' S* page_body '}' S*
         // page_body :  /* Can be empty */ declaration? [ ';' S* page_body ]? | page_margin_box page_body
         if (!this.peekKeyword('@page')) {
             return null;
         }
-        var node = this.create(nodes.Page);
+        const node = this.create(nodes.Page);
         this.consumeToken();
         if (node.addChild(this._parsePageSelector())) {
             while (this.accept(TokenType.Comma)) {
@@ -992,25 +1039,25 @@ var Parser = /** @class */ (function () {
             }
         }
         return this._parseBody(node, this._parsePageDeclaration.bind(this));
-    };
-    Parser.prototype._parsePageMarginBox = function () {
+    }
+    _parsePageMarginBox() {
         // page_margin_box :  margin_sym S* '{' S* declaration? [ ';' S* declaration? ]* '}' S*
         if (!this.peek(TokenType.AtKeyword)) {
             return null;
         }
-        var node = this.create(nodes.PageBoxMarginBox);
+        const node = this.create(nodes.PageBoxMarginBox);
         if (!this.acceptOneKeyword(languageFacts.pageBoxDirectives)) {
             this.markError(node, ParseError.UnknownAtRule, [], [TokenType.CurlyL]);
         }
         return this._parseBody(node, this._parseRuleSetDeclaration.bind(this));
-    };
-    Parser.prototype._parsePageSelector = function () {
+    }
+    _parsePageSelector() {
         // page_selector : pseudo_page+ | IDENT pseudo_page*
         // pseudo_page :  ':' [ "left" | "right" | "first" | "blank" ];
         if (!this.peek(TokenType.Ident) && !this.peek(TokenType.Colon)) {
             return null;
         }
-        var node = this.create(nodes.Node);
+        const node = this.create(nodes.Node);
         node.addChild(this._parseIdent()); // optional ident
         if (this.accept(TokenType.Colon)) {
             if (!node.addChild(this._parseIdent())) { // optional ident
@@ -1018,29 +1065,29 @@ var Parser = /** @class */ (function () {
             }
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseDocument = function () {
+    }
+    _parseDocument() {
         // -moz-document is experimental but has been pushed to css4
         if (!this.peekKeyword('@-moz-document')) {
             return null;
         }
-        var node = this.create(nodes.Document);
+        const node = this.create(nodes.Document);
         this.consumeToken(); // @-moz-document
         this.resync([], [TokenType.CurlyL]); // ignore all the rules
         return this._parseBody(node, this._parseStylesheetStatement.bind(this));
-    };
+    }
     // https://www.w3.org/TR/css-syntax-3/#consume-an-at-rule
-    Parser.prototype._parseUnknownAtRule = function () {
+    _parseUnknownAtRule() {
         if (!this.peek(TokenType.AtKeyword)) {
             return null;
         }
-        var node = this.create(nodes.UnknownAtRule);
+        const node = this.create(nodes.UnknownAtRule);
         node.addChild(this._parseUnknownAtRuleName());
-        var isTopLevel = function () { return curlyDepth === 0 && parensDepth === 0 && bracketsDepth === 0; };
-        var curlyLCount = 0;
-        var curlyDepth = 0;
-        var parensDepth = 0;
-        var bracketsDepth = 0;
+        const isTopLevel = () => curlyDepth === 0 && parensDepth === 0 && bracketsDepth === 0;
+        let curlyLCount = 0;
+        let curlyDepth = 0;
+        let parensDepth = 0;
+        let bracketsDepth = 0;
         done: while (true) {
             switch (this.token.type) {
                 case TokenType.SemiColon:
@@ -1109,15 +1156,15 @@ var Parser = /** @class */ (function () {
             this.consumeToken();
         }
         return node;
-    };
-    Parser.prototype._parseUnknownAtRuleName = function () {
-        var node = this.create(nodes.Node);
+    }
+    _parseUnknownAtRuleName() {
+        const node = this.create(nodes.Node);
         if (this.accept(TokenType.AtKeyword)) {
             return this.finish(node);
         }
         return node;
-    };
-    Parser.prototype._parseOperator = function () {
+    }
+    _parseOperator() {
         // these are operators for binary expressions
         if (this.peekDelim('/') ||
             this.peekDelim('*') ||
@@ -1129,27 +1176,27 @@ var Parser = /** @class */ (function () {
             this.peek(TokenType.PrefixOperator) ||
             this.peek(TokenType.SuffixOperator) ||
             this.peekDelim('=')) { // doesn't stick to the standard here
-            var node = this.createNode(nodes.NodeType.Operator);
+            const node = this.createNode(nodes.NodeType.Operator);
             this.consumeToken();
             return this.finish(node);
         }
         else {
             return null;
         }
-    };
-    Parser.prototype._parseUnaryOperator = function () {
+    }
+    _parseUnaryOperator() {
         if (!this.peekDelim('+') && !this.peekDelim('-')) {
             return null;
         }
-        var node = this.create(nodes.Node);
+        const node = this.create(nodes.Node);
         this.consumeToken();
         return this.finish(node);
-    };
-    Parser.prototype._parseCombinator = function () {
+    }
+    _parseCombinator() {
         if (this.peekDelim('>')) {
-            var node = this.create(nodes.Node);
+            const node = this.create(nodes.Node);
             this.consumeToken();
-            var mark = this.mark();
+            const mark = this.mark();
             if (!this.hasWhitespace() && this.acceptDelim('>')) {
                 if (!this.hasWhitespace() && this.acceptDelim('>')) {
                     node.type = nodes.NodeType.SelectorCombinatorShadowPiercingDescendant;
@@ -1161,21 +1208,21 @@ var Parser = /** @class */ (function () {
             return this.finish(node);
         }
         else if (this.peekDelim('+')) {
-            var node = this.create(nodes.Node);
+            const node = this.create(nodes.Node);
             this.consumeToken();
             node.type = nodes.NodeType.SelectorCombinatorSibling;
             return this.finish(node);
         }
         else if (this.peekDelim('~')) {
-            var node = this.create(nodes.Node);
+            const node = this.create(nodes.Node);
             this.consumeToken();
             node.type = nodes.NodeType.SelectorCombinatorAllSiblings;
             return this.finish(node);
         }
         else if (this.peekDelim('/')) {
-            var node = this.create(nodes.Node);
+            const node = this.create(nodes.Node);
             this.consumeToken();
-            var mark = this.mark();
+            const mark = this.mark();
             if (!this.hasWhitespace() && this.acceptIdent('deep') && !this.hasWhitespace() && this.acceptDelim('/')) {
                 node.type = nodes.NodeType.SelectorCombinatorShadowPiercingDescendant;
                 return this.finish(node);
@@ -1183,12 +1230,12 @@ var Parser = /** @class */ (function () {
             this.restoreAtMark(mark);
         }
         return null;
-    };
-    Parser.prototype._parseSimpleSelector = function () {
+    }
+    _parseSimpleSelector() {
         // simple_selector
         //  : element_name [ HASH | class | attrib | pseudo ]* | [ HASH | class | attrib | pseudo ]+ ;
-        var node = this.create(nodes.SimpleSelector);
-        var c = 0;
+        const node = this.create(nodes.SimpleSelector);
+        let c = 0;
         if (node.addChild(this._parseElementName())) {
             c++;
         }
@@ -1196,18 +1243,18 @@ var Parser = /** @class */ (function () {
             c++;
         }
         return c > 0 ? this.finish(node) : null;
-    };
-    Parser.prototype._parseSimpleSelectorBody = function () {
+    }
+    _parseSimpleSelectorBody() {
         return this._parsePseudo() || this._parseHash() || this._parseClass() || this._parseAttrib();
-    };
-    Parser.prototype._parseSelectorIdent = function () {
+    }
+    _parseSelectorIdent() {
         return this._parseIdent();
-    };
-    Parser.prototype._parseHash = function () {
+    }
+    _parseHash() {
         if (!this.peek(TokenType.Hash) && !this.peekDelim('#')) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.IdentifierSelector);
+        const node = this.createNode(nodes.NodeType.IdentifierSelector);
         if (this.acceptDelim('#')) {
             if (this.hasWhitespace() || !node.addChild(this._parseSelectorIdent())) {
                 return this.finish(node, ParseError.IdentifierExpected);
@@ -1217,33 +1264,33 @@ var Parser = /** @class */ (function () {
             this.consumeToken(); // TokenType.Hash
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseClass = function () {
+    }
+    _parseClass() {
         // class: '.' IDENT ;
         if (!this.peekDelim('.')) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.ClassSelector);
+        const node = this.createNode(nodes.NodeType.ClassSelector);
         this.consumeToken(); // '.'
         if (this.hasWhitespace() || !node.addChild(this._parseSelectorIdent())) {
             return this.finish(node, ParseError.IdentifierExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseElementName = function () {
+    }
+    _parseElementName() {
         // element_name: (ns? '|')? IDENT | '*';
-        var pos = this.mark();
-        var node = this.createNode(nodes.NodeType.ElementNameSelector);
+        const pos = this.mark();
+        const node = this.createNode(nodes.NodeType.ElementNameSelector);
         node.addChild(this._parseNamespacePrefix());
         if (!node.addChild(this._parseSelectorIdent()) && !this.acceptDelim('*')) {
             this.restoreAtMark(pos);
             return null;
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseNamespacePrefix = function () {
-        var pos = this.mark();
-        var node = this.createNode(nodes.NodeType.NamespacePrefix);
+    }
+    _parseNamespacePrefix() {
+        const pos = this.mark();
+        const node = this.createNode(nodes.NodeType.NamespacePrefix);
         if (!node.addChild(this._parseIdent()) && !this.acceptDelim('*')) {
             // ns is optional
         }
@@ -1252,13 +1299,13 @@ var Parser = /** @class */ (function () {
             return null;
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseAttrib = function () {
+    }
+    _parseAttrib() {
         // attrib : '[' S* IDENT S* [ [ '=' | INCLUDES | DASHMATCH ] S*   [ IDENT | STRING ] S* ]? ']'
         if (!this.peek(TokenType.BracketL)) {
             return null;
         }
-        var node = this.create(nodes.AttributeSelector);
+        const node = this.create(nodes.AttributeSelector);
         this.consumeToken(); // BracketL
         // Optional attrib namespace
         node.setNamespacePrefix(this._parseNamespacePrefix());
@@ -1274,23 +1321,22 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.RightSquareBracketExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parsePseudo = function () {
-        var _this = this;
+    }
+    _parsePseudo() {
         // pseudo: ':' [ IDENT | FUNCTION S* [IDENT S*]? ')' ]
-        var node = this._tryParsePseudoIdentifier();
+        const node = this._tryParsePseudoIdentifier();
         if (node) {
             if (!this.hasWhitespace() && this.accept(TokenType.ParenthesisL)) {
-                var tryAsSelector = function () {
-                    var selectors = _this.create(nodes.Node);
-                    if (!selectors.addChild(_this._parseSelector(false))) {
+                const tryAsSelector = () => {
+                    const selectors = this.create(nodes.Node);
+                    if (!selectors.addChild(this._parseSelector(true))) {
                         return null;
                     }
-                    while (_this.accept(TokenType.Comma) && selectors.addChild(_this._parseSelector(false))) {
+                    while (this.accept(TokenType.Comma) && selectors.addChild(this._parseSelector(true))) {
                         // loop
                     }
-                    if (_this.peek(TokenType.ParenthesisR)) {
-                        return _this.finish(selectors);
+                    if (this.peek(TokenType.ParenthesisR)) {
+                        return this.finish(selectors);
                     }
                     return null;
                 };
@@ -1302,13 +1348,13 @@ var Parser = /** @class */ (function () {
             return this.finish(node);
         }
         return null;
-    };
-    Parser.prototype._tryParsePseudoIdentifier = function () {
+    }
+    _tryParsePseudoIdentifier() {
         if (!this.peek(TokenType.Colon)) {
             return null;
         }
-        var pos = this.mark();
-        var node = this.createNode(nodes.NodeType.PseudoSelector);
+        const pos = this.mark();
+        const node = this.createNode(nodes.NodeType.PseudoSelector);
         this.consumeToken(); // Colon
         if (this.hasWhitespace()) {
             this.restoreAtMark(pos);
@@ -1320,29 +1366,28 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.IdentifierExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._tryParsePrio = function () {
-        var mark = this.mark();
-        var prio = this._parsePrio();
+    }
+    _tryParsePrio() {
+        const mark = this.mark();
+        const prio = this._parsePrio();
         if (prio) {
             return prio;
         }
         this.restoreAtMark(mark);
         return null;
-    };
-    Parser.prototype._parsePrio = function () {
+    }
+    _parsePrio() {
         if (!this.peek(TokenType.Exclamation)) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.Prio);
+        const node = this.createNode(nodes.NodeType.Prio);
         if (this.accept(TokenType.Exclamation) && this.acceptIdent('important')) {
             return this.finish(node);
         }
         return null;
-    };
-    Parser.prototype._parseExpr = function (stopOnComma) {
-        if (stopOnComma === void 0) { stopOnComma = false; }
-        var node = this.create(nodes.Expression);
+    }
+    _parseExpr(stopOnComma = false) {
+        const node = this.create(nodes.Expression);
         if (!node.addChild(this._parseBinaryExpr())) {
             return null;
         }
@@ -1358,23 +1403,23 @@ var Parser = /** @class */ (function () {
             }
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseUnicodeRange = function () {
+    }
+    _parseUnicodeRange() {
         if (!this.peekIdent('u')) {
             return null;
         }
-        var node = this.create(nodes.UnicodeRange);
+        const node = this.create(nodes.UnicodeRange);
         if (!this.acceptUnicodeRange()) {
             return null;
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseNamedLine = function () {
+    }
+    _parseNamedLine() {
         // https://www.w3.org/TR/css-grid-1/#named-lines
         if (!this.peek(TokenType.BracketL)) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.GridLine);
+        const node = this.createNode(nodes.NodeType.GridLine);
         this.consumeToken();
         while (node.addChild(this._parseIdent())) {
             // repeat
@@ -1383,9 +1428,9 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.RightSquareBracketExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseBinaryExpr = function (preparsedLeft, preparsedOper) {
-        var node = this.create(nodes.BinaryExpression);
+    }
+    _parseBinaryExpr(preparsedLeft, preparsedOper) {
+        let node = this.create(nodes.BinaryExpression);
         if (!node.setLeft((preparsedLeft || this._parseTerm()))) {
             return null;
         }
@@ -1397,21 +1442,21 @@ var Parser = /** @class */ (function () {
         }
         // things needed for multiple binary expressions
         node = this.finish(node);
-        var operator = this._parseOperator();
+        const operator = this._parseOperator();
         if (operator) {
             node = this._parseBinaryExpr(node, operator);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseTerm = function () {
-        var node = this.create(nodes.Term);
+    }
+    _parseTerm() {
+        let node = this.create(nodes.Term);
         node.setOperator(this._parseUnaryOperator()); // optional
         if (node.setExpression(this._parseTermExpression())) {
             return this.finish(node);
         }
         return null;
-    };
-    Parser.prototype._parseTermExpression = function () {
+    }
+    _parseTermExpression() {
         return this._parseURILiteral() || // url before function
             this._parseUnicodeRange() ||
             this._parseFunction() || // function before ident
@@ -1421,20 +1466,20 @@ var Parser = /** @class */ (function () {
             this._parseHexColor() ||
             this._parseOperation() ||
             this._parseNamedLine();
-    };
-    Parser.prototype._parseOperation = function () {
+    }
+    _parseOperation() {
         if (!this.peek(TokenType.ParenthesisL)) {
             return null;
         }
-        var node = this.create(nodes.Node);
+        const node = this.create(nodes.Node);
         this.consumeToken(); // ParenthesisL
         node.addChild(this._parseExpr());
         if (!this.accept(TokenType.ParenthesisR)) {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseNumeric = function () {
+    }
+    _parseNumeric() {
         if (this.peek(TokenType.Num) ||
             this.peek(TokenType.Percentage) ||
             this.peek(TokenType.Resolution) ||
@@ -1445,26 +1490,26 @@ var Parser = /** @class */ (function () {
             this.peek(TokenType.Time) ||
             this.peek(TokenType.Dimension) ||
             this.peek(TokenType.Freq)) {
-            var node = this.create(nodes.NumericValue);
+            const node = this.create(nodes.NumericValue);
             this.consumeToken();
             return this.finish(node);
         }
         return null;
-    };
-    Parser.prototype._parseStringLiteral = function () {
+    }
+    _parseStringLiteral() {
         if (!this.peek(TokenType.String) && !this.peek(TokenType.BadString)) {
             return null;
         }
-        var node = this.createNode(nodes.NodeType.StringLiteral);
+        const node = this.createNode(nodes.NodeType.StringLiteral);
         this.consumeToken();
         return this.finish(node);
-    };
-    Parser.prototype._parseURILiteral = function () {
+    }
+    _parseURILiteral() {
         if (!this.peekRegExp(TokenType.Ident, /^url(-prefix)?$/i)) {
             return null;
         }
-        var pos = this.mark();
-        var node = this.createNode(nodes.NodeType.URILiteral);
+        const pos = this.mark();
+        const node = this.createNode(nodes.NodeType.URILiteral);
         this.accept(TokenType.Ident);
         if (this.hasWhitespace() || !this.peek(TokenType.ParenthesisL)) {
             this.restoreAtMark(pos);
@@ -1478,29 +1523,29 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseURLArgument = function () {
-        var node = this.create(nodes.Node);
+    }
+    _parseURLArgument() {
+        const node = this.create(nodes.Node);
         if (!this.accept(TokenType.String) && !this.accept(TokenType.BadString) && !this.acceptUnquotedString()) {
             return null;
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseIdent = function (referenceTypes) {
+    }
+    _parseIdent(referenceTypes) {
         if (!this.peek(TokenType.Ident)) {
             return null;
         }
-        var node = this.create(nodes.Identifier);
+        const node = this.create(nodes.Identifier);
         if (referenceTypes) {
             node.referenceTypes = referenceTypes;
         }
         node.isCustomProperty = this.peekRegExp(TokenType.Ident, /^--/);
         this.consumeToken();
         return this.finish(node);
-    };
-    Parser.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;
         }
@@ -1522,12 +1567,12 @@ var Parser = /** @class */ (function () {
             return this.finish(node, ParseError.RightParenthesisExpected);
         }
         return this.finish(node);
-    };
-    Parser.prototype._parseFunctionIdentifier = function () {
+    }
+    _parseFunctionIdentifier() {
         if (!this.peek(TokenType.Ident)) {
             return null;
         }
-        var node = this.create(nodes.Identifier);
+        const node = this.create(nodes.Identifier);
         node.referenceTypes = [nodes.ReferenceType.Function];
         if (this.acceptIdent('progid')) {
             // support for IE7 specific filters: 'progid:DXImageTransform.Microsoft.MotionBlur(strength=13, direction=310)'
@@ -1540,24 +1585,22 @@ var Parser = /** @class */ (function () {
         }
         this.consumeToken();
         return this.finish(node);
-    };
-    Parser.prototype._parseFunctionArgument = function () {
-        var node = this.create(nodes.FunctionArgument);
+    }
+    _parseFunctionArgument() {
+        const node = this.create(nodes.FunctionArgument);
         if (node.setValue(this._parseExpr(true))) {
             return this.finish(node);
         }
         return null;
-    };
-    Parser.prototype._parseHexColor = function () {
+    }
+    _parseHexColor() {
         if (this.peekRegExp(TokenType.Hash, /^#([A-Fa-f0-9]{3}|[A-Fa-f0-9]{4}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/g)) {
-            var node = this.create(nodes.HexColorValue);
+            const node = this.create(nodes.HexColorValue);
             this.consumeToken();
             return this.finish(node);
         }
         else {
             return null;
         }
-    };
-    return Parser;
-}());
-export { Parser };
+    }
+}