xmlui 0.9.1 → 0.9.2

package/dist/scripts/src/parsers/scripting/Lexer.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lexer = void 0;
 const regexpp_1 = require("@eslint-community/regexpp");
-const Token_1 = require("../../abstractions/scripting/Token");
+const TokenType_1 = require("./TokenType");
 /**
  * This enum indicates the current lexer phase
  */
@@ -45,8 +45,8 @@ var LexerPhase;
     LexerPhase[LexerPhase["RealExponent"] = 30] = "RealExponent";
     LexerPhase[LexerPhase["RealExponentSign"] = 31] = "RealExponentSign";
     LexerPhase[LexerPhase["RealExponentTail"] = 32] = "RealExponentTail";
-    LexerPhase[LexerPhase["StringTemplateLiteral"] = 33] = "StringTemplateLiteral";
-    LexerPhase[LexerPhase["StringTemplateLiteralBackSlash"] = 34] = "StringTemplateLiteralBackSlash";
+    LexerPhase[LexerPhase["StringTemplateLiteralBackSlash"] = 33] = "StringTemplateLiteralBackSlash";
+    LexerPhase[LexerPhase["StringTemplateLiteral"] = 34] = "StringTemplateLiteral";
     LexerPhase[LexerPhase["String"] = 35] = "String";
     LexerPhase[LexerPhase["StringBackSlash"] = 36] = "StringBackSlash";
     LexerPhase[LexerPhase["StringHexa1"] = 37] = "StringHexa1";
@@ -157,11 +157,10 @@ class Lexer {
      */
     getTail() {
         return this._ahead.length > 0
-            ? this.input.getTail(this._ahead[0].location.startPosition)
+            ? this.input.getTail(this._ahead[0].startPosition)
             : this.input.getTail(this._lastFetchPosition);
     }
-    /**
-     * Parsing template literals requires a context sensitive lexer.
+    /** Parsing template literals requires a context sensitive lexer.
      * This method has to be called by the parser when the lexer needs to scan a string inside a template literal.
      * Call this after the first opening backing and after the parser is done with parsing a placeholder, after the right brace.
      */
@@ -193,7 +192,7 @@ class Lexer {
         // --- State variables
         let stringState = null;
         let text = "";
-        let tokenType = Token_1.TokenType.Eof;
+        let tokenType = TokenType_1.TokenType.Eof;
         let lastEndPos = input.position;
         let lastEndColumn = input.column;
         let ch = null;
@@ -209,8 +208,8 @@ class Lexer {
                 return makeToken();
             }
             // --- Set the initial token type to unknown for the other characters
-            if (tokenType === Token_1.TokenType.Eof) {
-                tokenType = Token_1.TokenType.Unknown;
+            if (tokenType === TokenType_1.TokenType.Eof) {
+                tokenType = TokenType_1.TokenType.Unknown;
             }
             // --- Follow the lexer state machine
             phaseSwitch: switch (phase) {
@@ -224,105 +223,105 @@ class Lexer {
                         case "\n":
                         case "\r":
                             phase = LexerPhase.InWhiteSpace;
-                            tokenType = Token_1.TokenType.Ws;
+                            tokenType = TokenType_1.TokenType.Ws;
                             break;
                         // --- Divide, BlockComment, or EolComment
                         case "/":
                             phase = LexerPhase.Slash;
-                            tokenType = Token_1.TokenType.Divide;
+                            tokenType = TokenType_1.TokenType.Divide;
                             break;
                         case "$":
                             phase = LexerPhase.Dollar;
-                            tokenType = Token_1.TokenType.Identifier;
+                            tokenType = TokenType_1.TokenType.Identifier;
                             break;
                         case "*":
                             phase = LexerPhase.Asterisk;
-                            tokenType = Token_1.TokenType.Multiply;
+                            tokenType = TokenType_1.TokenType.Multiply;
                             break;
                         case "%":
                             phase = LexerPhase.Remainder;
-                            tokenType = Token_1.TokenType.Remainder;
+                            tokenType = TokenType_1.TokenType.Remainder;
                             break;
                         case "+":
                             phase = LexerPhase.Plus;
-                            tokenType = Token_1.TokenType.Plus;
+                            tokenType = TokenType_1.TokenType.Plus;
                             break;
                         case "-":
                             phase = LexerPhase.Minus;
-                            tokenType = Token_1.TokenType.Minus;
+                            tokenType = TokenType_1.TokenType.Minus;
                             break;
                         case "^":
                             phase = LexerPhase.BitwiseXor;
-                            tokenType = Token_1.TokenType.BitwiseXor;
+                            tokenType = TokenType_1.TokenType.BitwiseXor;
                             break;
                         // --- BitwiseOr, LogicalOr
                         case "|":
                             phase = LexerPhase.Or;
-                            tokenType = Token_1.TokenType.BitwiseOr;
+                            tokenType = TokenType_1.TokenType.BitwiseOr;
                             break;
                         // --- BitwiseAnd, LogicalAnd
                         case "&":
                             phase = LexerPhase.Ampersand;
-                            tokenType = Token_1.TokenType.BitwiseAnd;
+                            tokenType = TokenType_1.TokenType.BitwiseAnd;
                             break;
                         // --- "?", "?", or "?."
                         case "?":
                             phase = LexerPhase.QuestionMark;
-                            tokenType = Token_1.TokenType.QuestionMark;
+                            tokenType = TokenType_1.TokenType.QuestionMark;
                             break;
                         case ";":
-                            return completeToken(Token_1.TokenType.Semicolon);
+                            return completeToken(TokenType_1.TokenType.Semicolon);
                         case ",":
-                            return completeToken(Token_1.TokenType.Comma);
+                            return completeToken(TokenType_1.TokenType.Comma);
                         case "(":
-                            return completeToken(Token_1.TokenType.LParent);
+                            return completeToken(TokenType_1.TokenType.LParent);
                         case ")":
-                            return completeToken(Token_1.TokenType.RParent);
+                            return completeToken(TokenType_1.TokenType.RParent);
                         // --- ":" or "::"
                         case ":":
                             phase = LexerPhase.Colon;
-                            tokenType = Token_1.TokenType.Colon;
+                            tokenType = TokenType_1.TokenType.Colon;
                             break;
                         case "`":
-                            return completeToken(Token_1.TokenType.Backtick);
+                            return completeToken(TokenType_1.TokenType.Backtick);
                         case "[":
-                            return completeToken(Token_1.TokenType.LSquare);
+                            return completeToken(TokenType_1.TokenType.LSquare);
                         case "]":
-                            return completeToken(Token_1.TokenType.RSquare);
+                            return completeToken(TokenType_1.TokenType.RSquare);
                         case "~":
-                            return completeToken(Token_1.TokenType.BinaryNot);
+                            return completeToken(TokenType_1.TokenType.BinaryNot);
                         case "{":
-                            return completeToken(Token_1.TokenType.LBrace);
+                            return completeToken(TokenType_1.TokenType.LBrace);
                         case "}":
-                            return completeToken(Token_1.TokenType.RBrace);
+                            return completeToken(TokenType_1.TokenType.RBrace);
                         // --- "=","==", "===", or "=>"
                         case "=":
                             phase = LexerPhase.Equal;
-                            tokenType = Token_1.TokenType.Assignment;
+                            tokenType = TokenType_1.TokenType.Assignment;
                             break;
                         // --- "!", "!=", or "!=="
                         case "!":
                             phase = LexerPhase.Exclamation;
-                            tokenType = Token_1.TokenType.LogicalNot;
+                            tokenType = TokenType_1.TokenType.LogicalNot;
                             break;
                         // --- "<", "<=", or "<<"
                         case "<":
                             phase = LexerPhase.AngleLeft;
-                            tokenType = Token_1.TokenType.LessThan;
+                            tokenType = TokenType_1.TokenType.LessThan;
                             break;
                         // --- ">", ">=", ">>", or ">>>"
                         case ">":
                             phase = LexerPhase.AngleRight;
-                            tokenType = Token_1.TokenType.GreaterThan;
+                            tokenType = TokenType_1.TokenType.GreaterThan;
                             break;
                         // --- Decimal or Real literal
                         case "0":
                             phase = LexerPhase.Zero;
-                            tokenType = Token_1.TokenType.DecimalLiteral;
+                            tokenType = TokenType_1.TokenType.DecimalLiteral;
                             break;
                         case ".":
                             phase = LexerPhase.Dot;
-                            tokenType = Token_1.TokenType.Dot;
+                            tokenType = TokenType_1.TokenType.Dot;
                             break;
                         // --- String (both " and ' are accepted as string wrappers
                         case '"':
@@ -334,32 +333,20 @@ class Lexer {
                             if (isIdStart(ch)) {
                                 useResolver = true;
                                 phase = LexerPhase.IdTail;
-                                tokenType = Token_1.TokenType.Identifier;
+                                tokenType = TokenType_1.TokenType.Identifier;
                             }
                             else if (isDecimalDigit(ch)) {
                                 phase = LexerPhase.DecimalOrReal;
-                                tokenType = Token_1.TokenType.DecimalLiteral;
+                                tokenType = TokenType_1.TokenType.DecimalLiteral;
                             }
                             else {
-                                completeToken(Token_1.TokenType.Unknown);
+                                completeToken(TokenType_1.TokenType.Unknown);
                             }
                             break;
                     }
                     break;
                 // ====================================================================
                 // Process comments
-                // A dollar sign is also a valid variable name. When it isn't a dollar left brace, we continue as if it was an identifier
-                case LexerPhase.Dollar:
-                    if (ch === "{") {
-                        return completeToken(Token_1.TokenType.DollarLBrace);
-                    }
-                    phase = LexerPhase.IdTail;
-                    useResolver = true;
-                    tokenType = Token_1.TokenType.Identifier;
-                    if (!isIdContinuation(ch)) {
-                        makeToken();
-                    }
-                    break;
                 // --- Looking for the end of whitespace
                 case LexerPhase.InWhiteSpace:
                     if (ch !== " " && ch !== "\t" && ch !== "\r" && ch !== "\n") {
@@ -375,7 +362,7 @@ class Lexer {
                 // --- Wait for a "/" that may complete a block comment
                 case LexerPhase.BlockCommentTrail2:
                     if (ch === "/") {
-                        return completeToken(Token_1.TokenType.BlockComment);
+                        return completeToken(TokenType_1.TokenType.BlockComment);
                     }
                     break;
                 case LexerPhase.InlineCommentTrail:
@@ -393,17 +380,17 @@ class Lexer {
                 // ====================================================================
                 // Process miscellaneous tokens
                 case LexerPhase.Colon:
-                    return ch === ":" ? completeToken(Token_1.TokenType.Global) : makeToken();
+                    return ch === ":" ? completeToken(TokenType_1.TokenType.Global) : makeToken();
                 case LexerPhase.Slash:
                     if (ch === "*") {
                         phase = LexerPhase.BlockCommentTrail1;
                     }
                     else if (ch === "/") {
                         phase = LexerPhase.InlineCommentTrail;
-                        tokenType = Token_1.TokenType.EolComment;
+                        tokenType = TokenType_1.TokenType.EolComment;
                     }
                     else if (ch === "=") {
-                        return completeToken(Token_1.TokenType.DivideAssignment);
+                        return completeToken(TokenType_1.TokenType.DivideAssignment);
                     }
                     else {
                         return makeToken();
@@ -411,142 +398,142 @@ class Lexer {
                     break;
                 case LexerPhase.Plus:
                     if (ch === "+") {
-                        return completeToken(Token_1.TokenType.IncOp);
+                        return completeToken(TokenType_1.TokenType.IncOp);
                     }
-                    return ch === "=" ? completeToken(Token_1.TokenType.AddAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.AddAssignment) : makeToken();
                 case LexerPhase.Minus:
                     if (ch === "-") {
-                        return completeToken(Token_1.TokenType.DecOp);
+                        return completeToken(TokenType_1.TokenType.DecOp);
                     }
-                    return ch === "=" ? completeToken(Token_1.TokenType.SubtractAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.SubtractAssignment) : makeToken();
                 case LexerPhase.Remainder:
-                    return ch === "=" ? completeToken(Token_1.TokenType.RemainderAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.RemainderAssignment) : makeToken();
                 case LexerPhase.BitwiseXor:
-                    return ch === "=" ? completeToken(Token_1.TokenType.BitwiseXorAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.BitwiseXorAssignment) : makeToken();
                 case LexerPhase.Or:
                     if (ch === "=") {
-                        return completeToken(Token_1.TokenType.BitwiseOrAssignment);
+                        return completeToken(TokenType_1.TokenType.BitwiseOrAssignment);
                     }
                     if (ch === "|") {
                         phase = LexerPhase.LogicalOr;
-                        tokenType = Token_1.TokenType.LogicalOr;
+                        tokenType = TokenType_1.TokenType.LogicalOr;
                         break;
                     }
                     return makeToken();
                 case LexerPhase.LogicalOr:
-                    return ch === "=" ? completeToken(Token_1.TokenType.LogicalOrAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.LogicalOrAssignment) : makeToken();
                 case LexerPhase.Ampersand:
                     if (ch === "=") {
-                        return completeToken(Token_1.TokenType.BitwiseAndAssignment);
+                        return completeToken(TokenType_1.TokenType.BitwiseAndAssignment);
                     }
                     if (ch === "&") {
                         phase = LexerPhase.LogicalAnd;
-                        tokenType = Token_1.TokenType.LogicalAnd;
+                        tokenType = TokenType_1.TokenType.LogicalAnd;
                         break;
                     }
                     return makeToken();
                 case LexerPhase.LogicalAnd:
-                    return ch === "=" ? completeToken(Token_1.TokenType.LogicalAndAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.LogicalAndAssignment) : makeToken();
                 case LexerPhase.Asterisk:
                     if (ch === "*") {
                         phase = LexerPhase.Exponent;
-                        tokenType = Token_1.TokenType.Exponent;
+                        tokenType = TokenType_1.TokenType.Exponent;
                         break;
                     }
                     else if (ch === "=") {
-                        return completeToken(Token_1.TokenType.MultiplyAssignment);
+                        return completeToken(TokenType_1.TokenType.MultiplyAssignment);
                     }
                     return makeToken();
                 case LexerPhase.Exponent:
-                    return ch === "=" ? completeToken(Token_1.TokenType.ExponentAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.ExponentAssignment) : makeToken();
                 case LexerPhase.QuestionMark:
                     if (ch === "?") {
                         phase = LexerPhase.NullCoalesce;
-                        tokenType = Token_1.TokenType.NullCoalesce;
+                        tokenType = TokenType_1.TokenType.NullCoalesce;
                         break;
                     }
                     if (ch === ".") {
-                        return completeToken(Token_1.TokenType.OptionalChaining);
+                        return completeToken(TokenType_1.TokenType.OptionalChaining);
                     }
                     return makeToken();
                 case LexerPhase.NullCoalesce:
-                    return ch === "=" ? completeToken(Token_1.TokenType.NullCoalesceAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.NullCoalesceAssignment) : makeToken();
                 case LexerPhase.Equal:
                     if (ch === ">") {
-                        return completeToken(Token_1.TokenType.Arrow);
+                        return completeToken(TokenType_1.TokenType.Arrow);
                     }
                     if (ch === "=") {
                         phase = LexerPhase.DoubleEqual;
-                        tokenType = Token_1.TokenType.Equal;
+                        tokenType = TokenType_1.TokenType.Equal;
                         break;
                     }
                     return makeToken();
                 case LexerPhase.DoubleEqual:
-                    return ch === "=" ? completeToken(Token_1.TokenType.StrictEqual) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.StrictEqual) : makeToken();
                 case LexerPhase.Exclamation:
                     if (ch === "=") {
                         phase = LexerPhase.NotEqual;
-                        tokenType = Token_1.TokenType.NotEqual;
+                        tokenType = TokenType_1.TokenType.NotEqual;
                         break;
                     }
                     return makeToken();
                 case LexerPhase.NotEqual:
-                    return ch === "=" ? completeToken(Token_1.TokenType.StrictNotEqual) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.StrictNotEqual) : makeToken();
                 case LexerPhase.AngleLeft:
                     if (ch === "=") {
-                        return completeToken(Token_1.TokenType.LessThanOrEqual);
+                        return completeToken(TokenType_1.TokenType.LessThanOrEqual);
                     }
                     if (ch === "<") {
                         phase = LexerPhase.ShiftLeft;
-                        tokenType = Token_1.TokenType.ShiftLeft;
+                        tokenType = TokenType_1.TokenType.ShiftLeft;
                         break;
                     }
                     return makeToken();
                 case LexerPhase.ShiftLeft:
-                    return ch === "=" ? completeToken(Token_1.TokenType.ShiftLeftAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.ShiftLeftAssignment) : makeToken();
                 case LexerPhase.AngleRight:
                     if (ch === "=") {
-                        return completeToken(Token_1.TokenType.GreaterThanOrEqual);
+                        return completeToken(TokenType_1.TokenType.GreaterThanOrEqual);
                     }
                     if (ch === ">") {
                         phase = LexerPhase.SignedShiftRight;
-                        tokenType = Token_1.TokenType.SignedShiftRight;
+                        tokenType = TokenType_1.TokenType.SignedShiftRight;
                         break;
                     }
                     return makeToken();
                 case LexerPhase.SignedShiftRight:
                     if (ch === ">") {
                         phase = LexerPhase.ShiftRight;
-                        tokenType = Token_1.TokenType.ShiftRight;
+                        tokenType = TokenType_1.TokenType.ShiftRight;
                         break;
                     }
                     if (ch === "=") {
-                        return completeToken(Token_1.TokenType.SignedShiftRightAssignment);
+                        return completeToken(TokenType_1.TokenType.SignedShiftRightAssignment);
                     }
                     return makeToken();
                 case LexerPhase.ShiftRight:
-                    return ch === "=" ? completeToken(Token_1.TokenType.ShiftRightAssignment) : makeToken();
+                    return ch === "=" ? completeToken(TokenType_1.TokenType.ShiftRightAssignment) : makeToken();
                 // ====================================================================
                 // --- Literals
                 case LexerPhase.Zero:
                     if (ch === "x") {
                         phase = LexerPhase.HexaFirst;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else if (ch === "b") {
                         phase = LexerPhase.BinaryFirst;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else if (isDecimalDigit(ch) || ch === "_") {
                         phase = LexerPhase.DecimalOrReal;
                     }
                     else if (ch === ".") {
                         phase = LexerPhase.RealFractionalFirst;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else if (ch === "e" || ch === "E") {
                         phase = LexerPhase.RealExponent;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else {
                         return makeToken();
@@ -555,17 +542,17 @@ class Lexer {
                 case LexerPhase.Dot:
                     if (ch === ".") {
                         phase = LexerPhase.DotDot;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                         break;
                     }
                     if (!isDecimalDigit(ch)) {
                         return makeToken();
                     }
                     phase = LexerPhase.RealFractionalTail;
-                    tokenType = Token_1.TokenType.RealLiteral;
+                    tokenType = TokenType_1.TokenType.RealLiteral;
                     break;
                 case LexerPhase.DotDot:
-                    return ch === "." ? completeToken(Token_1.TokenType.Spread) : makeToken();
+                    return ch === "." ? completeToken(TokenType_1.TokenType.Spread) : makeToken();
                 case LexerPhase.HexaFirst:
                     if (ch === "_") {
                         break;
@@ -574,7 +561,7 @@ class Lexer {
                         return makeToken();
                     }
                     phase = LexerPhase.HexaTail;
-                    tokenType = Token_1.TokenType.HexadecimalLiteral;
+                    tokenType = TokenType_1.TokenType.HexadecimalLiteral;
                     break;
                 case LexerPhase.HexaTail:
                     if (!isHexadecimalDigit(ch) && ch !== "_") {
@@ -589,26 +576,25 @@ class Lexer {
                         return makeToken();
                     }
                     phase = LexerPhase.BinaryTail;
-                    tokenType = Token_1.TokenType.BinaryLiteral;
+                    tokenType = TokenType_1.TokenType.BinaryLiteral;
                     break;
                 case LexerPhase.BinaryTail:
                     if (!isBinaryDigit(ch) && ch !== "_") {
                         return makeToken();
                     }
-                    tokenType = Token_1.TokenType.BinaryLiteral;
+                    tokenType = TokenType_1.TokenType.BinaryLiteral;
                     break;
                 case LexerPhase.DecimalOrReal:
                     if (isDecimalDigit(ch) || ch === "_") {
                         break;
                     }
-                    else if (ch === "." &&
-                        (this.input.peek() === null || isDecimalDigit(this.input.peek()))) {
+                    else if (ch === "." && (this.input.peek() === null || isDecimalDigit(this.input.peek()))) {
                         phase = LexerPhase.RealFractionalFirst;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else if (ch === "e" || ch === "E") {
                         phase = LexerPhase.RealExponent;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else {
                         return makeToken();
@@ -617,7 +603,7 @@ class Lexer {
                 case LexerPhase.RealFractionalFirst:
                     if (isDecimalDigit(ch)) {
                         phase = LexerPhase.RealFractionalTail;
-                        tokenType = Token_1.TokenType.RealLiteral;
+                        tokenType = TokenType_1.TokenType.RealLiteral;
                     }
                     else if (ch === "e" || ch === "E") {
                         phase = LexerPhase.RealExponent;
@@ -629,7 +615,7 @@ class Lexer {
                 case LexerPhase.RealFractionalTail:
                     if (ch === "e" || ch === "E") {
                         phase = LexerPhase.RealExponent;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     else if (!isDecimalDigit(ch) && ch !== "_") {
                         return makeToken();
@@ -641,7 +627,7 @@ class Lexer {
                     }
                     else if (isDecimalDigit(ch)) {
                         phase = LexerPhase.RealExponentTail;
-                        tokenType = Token_1.TokenType.RealLiteral;
+                        tokenType = TokenType_1.TokenType.RealLiteral;
                     }
                     else {
                         return makeToken();
@@ -650,7 +636,7 @@ class Lexer {
                 case LexerPhase.RealExponentSign:
                     if (isDecimalDigit(ch)) {
                         phase = LexerPhase.RealExponentTail;
-                        tokenType = Token_1.TokenType.RealLiteral;
+                        tokenType = TokenType_1.TokenType.RealLiteral;
                     }
                     else {
                         return makeToken();
@@ -661,12 +647,24 @@ class Lexer {
                         return makeToken();
                     }
                     break;
+                // A dollar sign is also a valid variable name. When it isn't a dollar left brace, we continue as if it was an identifier
+                case LexerPhase.Dollar:
+                    if (ch === "{") {
+                        return completeToken(TokenType_1.TokenType.DollarLBrace);
+                    }
+                    phase = LexerPhase.IdTail;
+                    useResolver = true;
+                    tokenType = TokenType_1.TokenType.Identifier;
+                    if (!isIdContinuation(ch)) {
+                        makeToken();
+                    }
+                    break;
                 case LexerPhase.StringTemplateLiteralBackSlash: {
                     phase = LexerPhase.StringTemplateLiteral;
                     const charAhead1 = this.input.ahead(0);
                     const charAhead2 = this.input.ahead(1);
                     if (charAhead1 === "`" || (charAhead1 === "$" && charAhead2 === "{")) {
-                        return completeToken(Token_1.TokenType.StringLiteral);
+                        return completeToken(TokenType_1.TokenType.StringLiteral);
                     }
                     break;
                 }
@@ -674,34 +672,34 @@ class Lexer {
                     switch (ch) {
                         case "\\":
                             phase = LexerPhase.StringTemplateLiteralBackSlash;
-                            tokenType = Token_1.TokenType.Unknown;
+                            tokenType = TokenType_1.TokenType.Unknown;
                             break phaseSwitch;
                         case "`":
-                            return completeToken(Token_1.TokenType.Backtick);
+                            return completeToken(TokenType_1.TokenType.Backtick);
                         case "$":
                             const charAhead = this.input.ahead(0);
                             if (charAhead === "{") {
                                 appendTokenChar();
                                 this.fetchNextChar();
-                                return completeToken(Token_1.TokenType.DollarLBrace);
+                                return completeToken(TokenType_1.TokenType.DollarLBrace);
                             }
                     }
                     const charAhead1 = this.input.ahead(0);
                     const charAhead2 = this.input.ahead(1);
                     if (charAhead1 === "`" || (charAhead1 === "$" && charAhead2 === "{")) {
-                        return completeToken(Token_1.TokenType.StringLiteral);
+                        return completeToken(TokenType_1.TokenType.StringLiteral);
                     }
                     break;
                 case LexerPhase.String:
                     if (ch === stringState) {
-                        return completeToken(Token_1.TokenType.StringLiteral);
+                        return completeToken(TokenType_1.TokenType.StringLiteral);
                     }
                     else if (isRestrictedInString(ch)) {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     else if (ch === "\\") {
                         phase = LexerPhase.StringBackSlash;
-                        tokenType = Token_1.TokenType.Unknown;
+                        tokenType = TokenType_1.TokenType.Unknown;
                     }
                     break;
                 // Start of string character escape
@@ -738,7 +736,7 @@ class Lexer {
                         phase = LexerPhase.StringHexa2;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Second hexadecimal digit of character escape
@@ -747,7 +745,7 @@ class Lexer {
                         phase = LexerPhase.String;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- First hexadecimal digit of Unicode string character escape
@@ -760,7 +758,7 @@ class Lexer {
                         phase = LexerPhase.StringUHexa2;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Second hexadecimal digit of Unicode string character escape
@@ -769,7 +767,7 @@ class Lexer {
                         phase = LexerPhase.StringUHexa3;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Third hexadecimal digit of Unicode string character escape
@@ -778,7 +776,7 @@ class Lexer {
                         phase = LexerPhase.StringUHexa4;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Fourth hexadecimal digit of Unicode string character escape
@@ -787,7 +785,7 @@ class Lexer {
                         phase = LexerPhase.String;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- First hexadecimal digit of Unicode codepoint string character escape
@@ -796,7 +794,7 @@ class Lexer {
                         phase = LexerPhase.StringUcp2;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Second hexadecimal digit of Unicode codepoint string character escape
@@ -808,7 +806,7 @@ class Lexer {
                         phase = LexerPhase.StringUcp3;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Third hexadecimal digit of Unicode codepoint string character escape
@@ -820,7 +818,7 @@ class Lexer {
                         phase = LexerPhase.StringUcp4;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Fourth hexadecimal digit of Unicode codepoint string character escape
@@ -832,7 +830,7 @@ class Lexer {
                         phase = LexerPhase.StringUcp5;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Fifth hexadecimal digit of Unicode codepoint string character escape
@@ -844,7 +842,7 @@ class Lexer {
                         phase = LexerPhase.StringUcp6;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Sixth hexadecimal digit of Unicode codepoint string character escape
@@ -856,7 +854,7 @@ class Lexer {
                         phase = LexerPhase.StringUcpTail;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // --- Closing bracket of Unicode codepoint string character escape
@@ -865,7 +863,7 @@ class Lexer {
                         phase = LexerPhase.String;
                     }
                     else {
-                        return completeToken(Token_1.TokenType.Unknown);
+                        return completeToken(TokenType_1.TokenType.Unknown);
                     }
                     break;
                 // ====================================================================
@@ -895,21 +893,17 @@ class Lexer {
             var _a;
             if (useResolver) {
                 tokenType =
-                    (_a = resolverHash.get(text)) !== null && _a !== void 0 ? _a : (isIdStart(text[0]) && text[text.length - 1] !== "'"
-                        ? Token_1.TokenType.Identifier
-                        : Token_1.TokenType.Unknown);
+                    (_a = resolverHash.get(text)) !== null && _a !== void 0 ? _a : (isIdStart(text[0]) && text[text.length - 1] !== "'" ? TokenType_1.TokenType.Identifier : TokenType_1.TokenType.Unknown);
             }
             return {
                 text,
                 type: tokenType,
-                location: {
-                    startPosition: startPos,
-                    endPosition: lastEndPos,
-                    startLine: line,
-                    endLine: line,
-                    startColumn,
-                    endColumn: lastEndColumn,
-                },
+                startPosition: startPos,
+                endPosition: lastEndPos,
+                startLine: line,
+                endLine: line,
+                startColumn,
+                endColumn: lastEndColumn,
             };
         }
         /**
@@ -937,7 +931,7 @@ class Lexer {
      */
     fetchRegEx() {
         // --- Get the tail
-        const tailPosition = this._ahead.length > 0 ? this._ahead[0].location.startPosition : this._lastFetchPosition;
+        const tailPosition = this._ahead.length > 0 ? this._ahead[0].startPosition : this._lastFetchPosition;
         const tail = this.input.getTail(tailPosition);
         // --- Parse the tail. If no error, the entire tail is the RegExp
         try {
@@ -1009,52 +1003,50 @@ exports.Lexer = Lexer;
  * Reserved ID-like tokens
  */
 const resolverHash = new Map();
-resolverHash.set("typeof", Token_1.TokenType.Typeof);
-resolverHash.set("Infinity", Token_1.TokenType.Infinity);
-resolverHash.set("NaN", Token_1.TokenType.NaN);
-resolverHash.set("true", Token_1.TokenType.True);
-resolverHash.set("false", Token_1.TokenType.False);
-resolverHash.set("undefined", Token_1.TokenType.Undefined);
-resolverHash.set("null", Token_1.TokenType.Null);
-resolverHash.set("in", Token_1.TokenType.In);
-resolverHash.set("let", Token_1.TokenType.Let);
-resolverHash.set("const", Token_1.TokenType.Const);
-resolverHash.set("var", Token_1.TokenType.Var);
-resolverHash.set("if", Token_1.TokenType.If);
-resolverHash.set("else", Token_1.TokenType.Else);
-resolverHash.set("return", Token_1.TokenType.Return);
-resolverHash.set("break", Token_1.TokenType.Break);
-resolverHash.set("continue", Token_1.TokenType.Continue);
-resolverHash.set("do", Token_1.TokenType.Do);
-resolverHash.set("while", Token_1.TokenType.While);
-resolverHash.set("for", Token_1.TokenType.For);
-resolverHash.set("of", Token_1.TokenType.Of);
-resolverHash.set("try", Token_1.TokenType.Try);
-resolverHash.set("catch", Token_1.TokenType.Catch);
-resolverHash.set("finally", Token_1.TokenType.Finally);
-resolverHash.set("throw", Token_1.TokenType.Throw);
-resolverHash.set("switch", Token_1.TokenType.Switch);
-resolverHash.set("case", Token_1.TokenType.Case);
-resolverHash.set("default", Token_1.TokenType.Default);
-resolverHash.set("delete", Token_1.TokenType.Delete);
-resolverHash.set("function", Token_1.TokenType.Function);
-resolverHash.set("export", Token_1.TokenType.Export);
-resolverHash.set("import", Token_1.TokenType.Import);
-resolverHash.set("as", Token_1.TokenType.As);
-resolverHash.set("from", Token_1.TokenType.From);
+resolverHash.set("typeof", TokenType_1.TokenType.Typeof);
+resolverHash.set("Infinity", TokenType_1.TokenType.Infinity);
+resolverHash.set("NaN", TokenType_1.TokenType.NaN);
+resolverHash.set("true", TokenType_1.TokenType.True);
+resolverHash.set("false", TokenType_1.TokenType.False);
+resolverHash.set("undefined", TokenType_1.TokenType.Undefined);
+resolverHash.set("null", TokenType_1.TokenType.Null);
+resolverHash.set("in", TokenType_1.TokenType.In);
+resolverHash.set("let", TokenType_1.TokenType.Let);
+resolverHash.set("const", TokenType_1.TokenType.Const);
+resolverHash.set("var", TokenType_1.TokenType.Var);
+resolverHash.set("if", TokenType_1.TokenType.If);
+resolverHash.set("else", TokenType_1.TokenType.Else);
+resolverHash.set("return", TokenType_1.TokenType.Return);
+resolverHash.set("break", TokenType_1.TokenType.Break);
+resolverHash.set("continue", TokenType_1.TokenType.Continue);
+resolverHash.set("do", TokenType_1.TokenType.Do);
+resolverHash.set("while", TokenType_1.TokenType.While);
+resolverHash.set("for", TokenType_1.TokenType.For);
+resolverHash.set("of", TokenType_1.TokenType.Of);
+resolverHash.set("try", TokenType_1.TokenType.Try);
+resolverHash.set("catch", TokenType_1.TokenType.Catch);
+resolverHash.set("finally", TokenType_1.TokenType.Finally);
+resolverHash.set("throw", TokenType_1.TokenType.Throw);
+resolverHash.set("switch", TokenType_1.TokenType.Switch);
+resolverHash.set("case", TokenType_1.TokenType.Case);
+resolverHash.set("default", TokenType_1.TokenType.Default);
+resolverHash.set("delete", TokenType_1.TokenType.Delete);
+resolverHash.set("function", TokenType_1.TokenType.Function);
+resolverHash.set("as", TokenType_1.TokenType.As);
+resolverHash.set("from", TokenType_1.TokenType.From);
 /**
  * Tests if a token id EOF
  * @param t Token instance
  */
 function isEof(t) {
-    return t.type === Token_1.TokenType.Eof;
+    return t.type === TokenType_1.TokenType.Eof;
 }
 /**
  * Tests if a token is whitespace
  * @param t Token instance
  */
 function isWs(t) {
-    return t.type <= Token_1.TokenType.Ws;
+    return t.type <= TokenType_1.TokenType.Ws;
 }
 /**
  * Tests if a character is an identifier start character
@@ -1068,11 +1060,7 @@ function isIdStart(ch) {
  * @param ch Character to test
  */
 function isIdContinuation(ch) {
-    return ((ch >= "a" && ch <= "z") ||
-        (ch >= "A" && ch <= "Z") ||
-        (ch >= "0" && ch <= "9") ||
-        ch === "_" ||
-        ch === "$");
+    return (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") || (ch >= "0" && ch <= "9") || ch === "_" || ch === "$";
 }
 /**
  * Tests if a character is a binary digit