@putout/babel 5.0.6 → 5.0.7

package/bundle/index.js

@@ -18937,16 +18937,7 @@ var tt = {
         beforeExpr,
         startsExpr,
     }),
-    bracketHashL: createToken('#[', {
-        beforeExpr,
-        startsExpr,
-    }),
-    bracketBarL: createToken('[|', {
-        beforeExpr,
-        startsExpr,
-    }),
     bracketR: createToken(']'),
-    bracketBarR: createToken('|]'),
     braceL: createToken('{', {
         beforeExpr,
         startsExpr,
@@ -18955,10 +18946,6 @@ var tt = {
         beforeExpr,
         startsExpr,
     }),
-    braceHashL: createToken('#{', {
-        beforeExpr,
-        startsExpr,
-    }),
     braceR: createToken('}'),
     braceBarR: createToken('|}'),
     parenL: createToken('(', {
@@ -19308,9 +19295,6 @@ var tt = {
     bigint: createToken('bigint', {
         startsExpr,
     }),
-    decimal: createToken('decimal', {
-        startsExpr,
-    }),
     regexp: createToken('regexp', {
         startsExpr,
     }),
@@ -19329,19 +19313,19 @@ var tt = {
 };
 
 function tokenIsIdentifier(token) {
-    return token >= 93 && token <= 133;
+    return token >= 89 && token <= 129;
 }
 
 function tokenKeywordOrIdentifierIsKeyword(token) {
-    return token <= 92;
+    return token <= 88;
 }
 
 function tokenIsKeywordOrIdentifier(token) {
-    return token >= 58 && token <= 133;
+    return token >= 54 && token <= 129;
 }
 
 function tokenIsLiteralPropertyName(token) {
-    return token >= 58 && token <= 137;
+    return token >= 54 && token <= 132;
 }
 
 function tokenComesBeforeExpression(token) {
@@ -19353,23 +19337,23 @@ function tokenCanStartExpression(token) {
 }
 
 function tokenIsAssignment(token) {
-    return token >= 29 && token <= 33;
+    return token >= 25 && token <= 29;
 }
 
 function tokenIsLoop(token) {
-    return token >= 90 && token <= 92;
+    return token >= 86 && token <= 88;
 }
 
 function tokenIsKeyword(token) {
-    return token >= 58 && token <= 92;
+    return token >= 54 && token <= 88;
 }
 
 function tokenIsOperator(token) {
-    return token >= 39 && token <= 59;
+    return token >= 35 && token <= 55;
 }
 
 function tokenIsPostfix(token) {
-    return token === 34;
+    return token === 30;
 }
 
 function tokenIsPrefix(token) {
@@ -19377,11 +19361,11 @@ function tokenIsPrefix(token) {
 }
 
 function tokenIsTSTypeOperator(token) {
-    return token >= 121 && token <= 123;
+    return token >= 117 && token <= 119;
 }
 
 function tokenIsTSDeclarationStart(token) {
-    return token >= 124 && token <= 130;
+    return token >= 120 && token <= 126;
 }
 
 function tokenLabelName(token) {
@@ -19393,11 +19377,11 @@ function tokenOperatorPrecedence(token) {
 }
 
 function tokenIsRightAssociative(token) {
-    return token === 57;
+    return token === 53;
 }
 
 function tokenIsTemplate(token) {
-    return token >= 24 && token <= 25;
+    return token >= 20 && token <= 21;
 }
 
 function getExportedToken(token) {
@@ -21137,7 +21121,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
                 if (this.state.pos === this.state.start) {
                     if (ch === 60 && this.state.canStartJSXElement) {
                         ++this.state.pos;
-                        this.finishToken(143);
+                        this.finishToken(138);
                     } else {
                         super.getTokenFromCode(ch);
                     }
@@ -21146,7 +21130,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
                 }
                 
                 out += this.input.slice(chunkStart, this.state.pos);
-                this.finishToken(142, out);
+                this.finishToken(137, out);
                 return;
             
             case 38:
@@ -21219,7 +21203,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         }
         
         out += this.input.slice(chunkStart, this.state.pos++);
-        this.finishToken(134, out);
+        this.finishToken(130, out);
     }
     
     jsxReadEntity() {
@@ -21270,13 +21254,13 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         do {
             ch = this.input.charCodeAt(++this.state.pos);
         } while (isIdentifierChar2(ch) || ch === 45)
-        this.finishToken(141, this.input.slice(start, this.state.pos));
+        this.finishToken(136, this.input.slice(start, this.state.pos));
     }
     
     jsxParseIdentifier() {
         const node = this.startNode();
         
-        if (this.match(141)) {
+        if (this.match(136)) {
             node.name = this.state.value;
         } else if (tokenIsKeyword(this.state.type)) {
             node.name = tokenLabelName(this.state.type);
@@ -21292,7 +21276,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         const startLoc = this.state.startLoc;
         const name = this.jsxParseIdentifier();
         
-        if (!this.eat(14))
+        if (!this.eat(10))
             return name;
         
         const node = this.startNodeAt(startLoc);
@@ -21310,7 +21294,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
             return node;
         }
         
-        while (this.eat(16)) {
+        while (this.eat(12)) {
             const newNode = this.startNodeAt(startLoc);
             
             newNode.object = node;
@@ -21325,7 +21309,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         let node;
         
         switch(this.state.type) {
-        case 5:
+        case 2:
             node = this.startNode();
             this.setContext(types.brace);
             this.next();
@@ -21337,8 +21321,8 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
             
             return node;
         
-        case 143:        
-        case 134:
+        case 138:        
+        case 130:
             return this.parseExprAtom();
         
         default:
@@ -21356,12 +21340,12 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         node.expression = this.parseExpression();
         this.setContext(types.j_expr);
         this.state.canStartJSXElement = true;
-        this.expect(8);
+        this.expect(4);
         return this.finishNode(node, 'JSXSpreadChild');
     }
     
     jsxParseExpressionContainer(node, previousContext) {
-        if (this.match(8)) {
+        if (this.match(4)) {
             node.expression = this.jsxParseEmptyExpression();
         } else {
             const expression2 = this.parseExpression();
@@ -21375,33 +21359,33 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         
         this.setContext(previousContext);
         this.state.canStartJSXElement = true;
-        this.expect(8);
+        this.expect(4);
         return this.finishNode(node, 'JSXExpressionContainer');
     }
     
     jsxParseAttribute() {
         const node = this.startNode();
         
-        if (this.match(5)) {
+        if (this.match(2)) {
             this.setContext(types.brace);
             this.next();
-            this.expect(21);
+            this.expect(17);
             node.argument = this.parseMaybeAssignAllowIn();
             this.setContext(types.j_oTag);
             this.state.canStartJSXElement = true;
-            this.expect(8);
+            this.expect(4);
             return this.finishNode(node, 'JSXSpreadAttribute');
         }
         
         node.name = this.jsxParseNamespacedName();
-        node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
+        node.value = this.eat(25) ? this.jsxParseAttributeValue() : null;
         return this.finishNode(node, 'JSXAttribute');
     }
     
     jsxParseOpeningElementAt(startLoc) {
         const node = this.startNodeAt(startLoc);
         
-        if (this.eat(144)) {
+        if (this.eat(139)) {
             return this.finishNode(node, 'JSXOpeningFragment');
         }
         
@@ -21412,25 +21396,25 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
     jsxParseOpeningElementAfterName(node) {
         const attributes = [];
         
-        while (!this.match(56) && !this.match(144)) {
+        while (!this.match(52) && !this.match(139)) {
             attributes.push(this.jsxParseAttribute());
         }
         
         node.attributes = attributes;
-        node.selfClosing = this.eat(56);
-        this.expect(144);
+        node.selfClosing = this.eat(52);
+        this.expect(139);
         return this.finishNode(node, 'JSXOpeningElement');
     }
     
     jsxParseClosingElementAt(startLoc) {
         const node = this.startNodeAt(startLoc);
         
-        if (this.eat(144)) {
+        if (this.eat(139)) {
             return this.finishNode(node, 'JSXClosingFragment');
         }
         
         node.name = this.jsxParseElementName();
-        this.expect(144);
+        this.expect(139);
         return this.finishNode(node, 'JSXClosingElement');
     }
     
@@ -21443,11 +21427,11 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         if (!openingElement.selfClosing) {
             contents: for (;;) {
                 switch(this.state.type) {
-                case 143:
+                case 138:
                     startLoc = this.state.startLoc;
                     this.next();
                     
-                    if (this.eat(56)) {
+                    if (this.eat(52)) {
                         closingElement = this.jsxParseClosingElementAt(startLoc);
                         break contents;
                     }
@@ -21455,16 +21439,16 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
                     children.push(this.jsxParseElementAt(startLoc));
                     break;
                 
-                case 142:
+                case 137:
                     children.push(this.parseLiteral(this.state.value, 'JSXText'));
                     break;
                 
-                case 5: {
+                case 2: {
                     const node2 = this.startNode();
                     this.setContext(types.brace);
                     this.next();
                     
-                    if (this.match(21)) {
+                    if (this.match(17)) {
                         children.push(this.jsxParseSpreadChild(node2));
                     } else {
                         children.push(this.jsxParseExpressionContainer(node2, types.j_expr));
@@ -21503,7 +21487,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         
         node.children = children;
         
-        if (this.match(47)) {
+        if (this.match(43)) {
             throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);
         }
         
@@ -21523,10 +21507,10 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
     }
     
     parseExprAtom(refExpressionErrors) {
-        if (this.match(143)) {
+        if (this.match(138)) {
             return this.jsxParseElement();
-        } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
-            this.replaceToken(143);
+        } else if (this.match(43) && this.input.charCodeAt(this.state.pos) !== 33) {
+            this.replaceToken(138);
             return this.jsxParseElement();
         } else {
             return super.parseExprAtom(refExpressionErrors);
@@ -21556,7 +21540,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
             
             if (code2 === 62) {
                 ++this.state.pos;
-                this.finishToken(144);
+                this.finishToken(139);
                 return;
             }
             
@@ -21568,7 +21552,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
         
         if (code2 === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
             ++this.state.pos;
-            this.finishToken(143);
+            this.finishToken(138);
             return;
         }
         
@@ -21578,15 +21562,15 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
     updateContext(prevType) {
         const {context, type} = this.state;
         
-        if (type === 56 && prevType === 143) {
+        if (type === 52 && prevType === 138) {
             context.splice(-2, 2, types.j_cTag);
             this.state.canStartJSXElement = false;
-        } else if (type === 143) {
+        } else if (type === 138) {
             context.push(types.j_oTag);
-        } else if (type === 144) {
+        } else if (type === 139) {
             const out = context[context.length - 1];
             
-            if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {
+            if (out === types.j_oTag && prevType === 52 || out === types.j_cTag) {
                 context.pop();
                 this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
             } else {
@@ -22061,7 +22045,7 @@ var State = class _State {
         __publicField(this, 'commentsLen', 0);
         __publicField(this, 'commentStack', []);
         __publicField(this, 'pos', 0);
-        __publicField(this, 'type', 140);
+        __publicField(this, 'type', 135);
         __publicField(this, 'value', null);
         __publicField(this, 'start', 0);
         __publicField(this, 'end', 0);
@@ -22815,7 +22799,7 @@ var Tokenizer = class extends CommentsParser {
             this.state.startLoc = this.state.curPosition();
         
         if (this.state.pos >= this.length) {
-            this.finishToken(140);
+            this.finishToken(135);
             return;
         }
         
@@ -23033,12 +23017,12 @@ var Tokenizer = class extends CommentsParser {
         
         if (isIdentifierStart2(next)) {
             ++this.state.pos;
-            this.finishToken(139, this.readWord1(next));
+            this.finishToken(134, this.readWord1(next));
         } else if (next === 92) {
             ++this.state.pos;
-            this.finishToken(139, this.readWord1());
+            this.finishToken(134, this.readWord1());
         } else {
-            this.finishOp(27, 1);
+            this.finishOp(23, 1);
         }
     }
     
@@ -23052,10 +23036,10 @@ var Tokenizer = class extends CommentsParser {
         
         if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
             this.state.pos += 3;
-            this.finishToken(21);
+            this.finishToken(17);
         } else {
             ++this.state.pos;
-            this.finishToken(16);
+            this.finishToken(12);
         }
     }
     
@@ -23063,9 +23047,9 @@ var Tokenizer = class extends CommentsParser {
         const next = this.input.charCodeAt(this.state.pos + 1);
         
         if (next === 61) {
-            this.finishOp(31, 2);
+            this.finishOp(27, 2);
         } else {
-            this.finishOp(56, 1);
+            this.finishOp(52, 1);
         }
     }
     
@@ -23086,24 +23070,24 @@ var Tokenizer = class extends CommentsParser {
         }
         
         const value = this.input.slice(start + 2, this.state.pos);
-        this.finishToken(28, value);
+        this.finishToken(24, value);
         return true;
     }
     
     readToken_mult_modulo(code2) {
-        let type = code2 === 42 ? 55 : 54;
+        let type = code2 === 42 ? 51 : 50;
         let width = 1;
         let next = this.input.charCodeAt(this.state.pos + 1);
         
         if (code2 === 42 && next === 42) {
             width++;
             next = this.input.charCodeAt(this.state.pos + 2);
-            type = 57;
+            type = 53;
         }
         
         if (next === 61 && !this.state.inType) {
             width++;
-            type = code2 === 37 ? 33 : 30;
+            type = code2 === 37 ? 29 : 26;
         }
         
         this.finishOp(type, width);
@@ -23114,9 +23098,9 @@ var Tokenizer = class extends CommentsParser {
         
         if (next === code2) {
             if (this.input.charCodeAt(this.state.pos + 2) === 61) {
-                this.finishOp(30, 3);
+                this.finishOp(26, 3);
             } else {
-                this.finishOp(code2 === 124 ? 41 : 42, 2);
+                this.finishOp(code2 === 124 ? 37 : 38, 2);
             }
             
             return;
@@ -23124,33 +23108,33 @@ var Tokenizer = class extends CommentsParser {
         
         if (code2 === 124) {
             if (next === 62) {
-                this.finishOp(39, 2);
+                this.finishOp(35, 2);
                 return;
             }
         }
         
         if (next === 61) {
-            this.finishOp(30, 2);
+            this.finishOp(26, 2);
             return;
         }
         
-        this.finishOp(code2 === 124 ? 43 : 45, 1);
+        this.finishOp(code2 === 124 ? 39 : 41, 1);
     }
     
     readToken_caret() {
         const next = this.input.charCodeAt(this.state.pos + 1);
         
         if (next === 61 && !this.state.inType) {
-            this.finishOp(32, 2);
+            this.finishOp(28, 2);
         } else if (next === 94 && this.hasPlugin(['pipelineOperator', {proposal: 'hack', topicToken: '^^'}])) {
-            this.finishOp(37, 2);
+            this.finishOp(33, 2);
             const lookaheadCh = this.input.codePointAt(this.state.pos);
             
             if (lookaheadCh === 94) {
                 this.unexpected();
             }
         } else {
-            this.finishOp(44, 1);
+            this.finishOp(40, 1);
         }
     }
     
@@ -23158,9 +23142,9 @@ var Tokenizer = class extends CommentsParser {
         const next = this.input.charCodeAt(this.state.pos + 1);
         
         if (next === 64 && this.hasPlugin(['pipelineOperator', {proposal: 'hack', topicToken: '@@'}])) {
-            this.finishOp(38, 2);
+            this.finishOp(34, 2);
         } else {
-            this.finishOp(26, 1);
+            this.finishOp(22, 1);
         }
     }
     
@@ -23168,14 +23152,14 @@ var Tokenizer = class extends CommentsParser {
         const next = this.input.charCodeAt(this.state.pos + 1);
         
         if (next === code2) {
-            this.finishOp(34, 2);
+            this.finishOp(30, 2);
             return;
         }
         
         if (next === 61) {
-            this.finishOp(30, 2);
+            this.finishOp(26, 2);
         } else {
-            this.finishOp(53, 1);
+            this.finishOp(49, 1);
         }
     }
     
@@ -23186,20 +23170,20 @@ var Tokenizer = class extends CommentsParser {
         
         if (next === 60) {
             if (this.input.charCodeAt(pos + 2) === 61) {
-                this.finishOp(30, 3);
+                this.finishOp(26, 3);
                 return;
             }
             
-            this.finishOp(51, 2);
+            this.finishOp(47, 2);
             return;
         }
         
         if (next === 61) {
-            this.finishOp(49, 2);
+            this.finishOp(45, 2);
             return;
         }
         
-        this.finishOp(47, 1);
+        this.finishOp(43, 1);
     }
     
     readToken_gt() {
@@ -23211,37 +23195,37 @@ var Tokenizer = class extends CommentsParser {
             const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;
             
             if (this.input.charCodeAt(pos + size) === 61) {
-                this.finishOp(30, size + 1);
+                this.finishOp(26, size + 1);
                 return;
             }
             
-            this.finishOp(52, size);
+            this.finishOp(48, size);
             return;
         }
         
         if (next === 61) {
-            this.finishOp(49, 2);
+            this.finishOp(45, 2);
             return;
         }
         
-        this.finishOp(48, 1);
+        this.finishOp(44, 1);
     }
     
     readToken_eq_excl(code2) {
         const next = this.input.charCodeAt(this.state.pos + 1);
         
         if (next === 61) {
-            this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
+            this.finishOp(42, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
             return;
         }
         
         if (code2 === 61 && next === 62) {
             this.state.pos += 2;
-            this.finishToken(19);
+            this.finishToken(15);
             return;
         }
         
-        this.finishOp(code2 === 61 ? 29 : 35, 1);
+        this.finishOp(code2 === 61 ? 25 : 31, 1);
     }
     
     readToken_question() {
@@ -23250,16 +23234,16 @@ var Tokenizer = class extends CommentsParser {
         
         if (next === 63) {
             if (next2 === 61) {
-                this.finishOp(30, 3);
+                this.finishOp(26, 3);
             } else {
-                this.finishOp(40, 2);
+                this.finishOp(36, 2);
             }
         } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
             this.state.pos += 2;
-            this.finishToken(18);
+            this.finishToken(14);
         } else {
             ++this.state.pos;
-            this.finishToken(17);
+            this.finishToken(13);
         }
     }
     
@@ -23271,22 +23255,22 @@ var Tokenizer = class extends CommentsParser {
         
         case 40:
             ++this.state.pos;
-            this.finishToken(10);
+            this.finishToken(6);
             return;
         
         case 41:
             ++this.state.pos;
-            this.finishToken(11);
+            this.finishToken(7);
             return;
         
         case 59:
             ++this.state.pos;
-            this.finishToken(13);
+            this.finishToken(9);
             return;
         
         case 44:
             ++this.state.pos;
-            this.finishToken(12);
+            this.finishToken(8);
             return;
         
         case 91:
@@ -23296,25 +23280,25 @@ var Tokenizer = class extends CommentsParser {
         
         case 93:
             ++this.state.pos;
-            this.finishToken(3);
+            this.finishToken(1);
             return;
         
         case 123:
             ++this.state.pos;
-            this.finishToken(5);
+            this.finishToken(2);
             return;
         
         case 125:
             ++this.state.pos;
-            this.finishToken(8);
+            this.finishToken(4);
             return;
         
         case 58:
             if (this.hasPlugin('functionBind') && this.input.charCodeAt(this.state.pos + 1) === 58) {
-                this.finishOp(15, 2);
+                this.finishOp(11, 2);
             } else {
                 ++this.state.pos;
-                this.finishToken(14);
+                this.finishToken(10);
             }
             
             return;
@@ -23400,7 +23384,7 @@ var Tokenizer = class extends CommentsParser {
             return;
         
         case 126:
-            this.finishOp(36, 1);
+            this.finishOp(32, 1);
             return;
         
         case 64:
@@ -23501,7 +23485,7 @@ var Tokenizer = class extends CommentsParser {
         }
         
         this.state.pos = pos;
-        this.finishToken(138, {
+        this.finishToken(133, {
             pattern: content,
             flags: mods,
         });
@@ -23546,11 +23530,11 @@ var Tokenizer = class extends CommentsParser {
                 .state
                 .pos)
                 .replace(/[_n]/g, '');
-            this.finishToken(136, str);
+            this.finishToken(132, str);
             return;
         }
         
-        this.finishToken(135, val);
+        this.finishToken(131, val);
     }
     
     readNumber(startsWithDot) {
@@ -23629,12 +23613,12 @@ var Tokenizer = class extends CommentsParser {
             .replace(/[_mn]/g, '');
         
         if (isBigInt) {
-            this.finishToken(136, str);
+            this.finishToken(132, str);
             return;
         }
         
         const val = isOctal ? parseInt(str, 8) : parseFloat(str);
-        this.finishToken(135, val);
+        this.finishToken(131, val);
     }
     
     readCodePoint(throwOnInvalid) {
@@ -23655,12 +23639,12 @@ var Tokenizer = class extends CommentsParser {
         this.state.pos = pos + 1;
         this.state.lineStart = lineStart;
         this.state.curLine = curLine;
-        this.finishToken(134, str);
+        this.finishToken(130, str);
     }
     
     readTemplateContinuation() {
-        if (!this.match(8)) {
-            this.unexpected(null, 8);
+        if (!this.match(4)) {
+            this.unexpected(null, 4);
         }
         
         this.state.pos--;
@@ -23686,10 +23670,10 @@ var Tokenizer = class extends CommentsParser {
         }
         
         if (this.input.codePointAt(pos) === 96) {
-            this.finishToken(24, firstInvalidLoc ? null : opening + str + '`');
+            this.finishToken(20, firstInvalidLoc ? null : opening + str + '`');
         } else {
             this.state.pos++;
-            this.finishToken(25, firstInvalidLoc ? null : opening + str + '${');
+            this.finishToken(21, firstInvalidLoc ? null : opening + str + '${');
         }
     }
     
@@ -23757,7 +23741,7 @@ var Tokenizer = class extends CommentsParser {
         if (type !== void 0) {
             this.finishToken(type, tokenLabelName(type));
         } else {
-            this.finishToken(132, word);
+            this.finishToken(128, word);
         }
     }
     
@@ -24128,7 +24112,7 @@ var UtilParser = class extends Tokenizer {
     }
     
     canInsertSemicolon() {
-        return this.match(140) || this.match(8) || this.hasPrecedingLineBreak();
+        return this.match(135) || this.match(4) || this.hasPrecedingLineBreak();
     }
     
     hasPrecedingLineBreak() {
@@ -24140,11 +24124,11 @@ var UtilParser = class extends Tokenizer {
     }
     
     isLineTerminator() {
-        return this.eat(13) || this.canInsertSemicolon();
+        return this.eat(9) || this.canInsertSemicolon();
     }
     
     semicolon(allowAsi = true) {
-        if (allowAsi ? this.isLineTerminator() : this.eat(13))
+        if (allowAsi ? this.isLineTerminator() : this.eat(9))
             return;
         
         this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);
@@ -24711,14 +24695,14 @@ var LValParser = class extends NodeUtils {
         case 0: {
             const node = this.startNode();
             this.next();
-            node.elements = this.parseBindingList(3, 93, 1);
+            node.elements = this.parseBindingList(1, 93, 1);
             return this.finishNode(node, 'ArrayPattern');
         }
         
-        case 5:
-            return this.parseObjectLike(8, true);
+        case 2:
+            return this.parseObjectLike(4, true);
         
-        case 88:
+        case 84:
             return this.parseVoidPattern(null);
         }
         
@@ -24734,14 +24718,14 @@ var LValParser = class extends NodeUtils {
             if (first) {
                 first = false;
             } else {
-                this.expect(12);
+                this.expect(8);
             }
             
-            if (allowEmpty && this.match(12)) {
+            if (allowEmpty && this.match(8)) {
                 elts.push(null);
             } else if (this.eat(close)) {
                 break;
-            } else if (this.match(21)) {
+            } else if (this.match(17)) {
                 let rest = this.parseRestBinding();
                 
                 if (flags & 2) {
@@ -24758,11 +24742,11 @@ var LValParser = class extends NodeUtils {
                 const decorators = [];
                 
                 if (flags & 2) {
-                    if (this.match(26) && this.hasPlugin('decorators')) {
+                    if (this.match(22) && this.hasPlugin('decorators')) {
                         this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);
                     }
                     
-                    while (this.match(26)) {
+                    while (this.match(22)) {
                         decorators.push(this.parseDecorator());
                     }
                 }
@@ -24778,7 +24762,7 @@ var LValParser = class extends NodeUtils {
     parseBindingRestProperty(prop) {
         this.next();
         
-        if (this.hasPlugin('discardBinding') && this.match(88)) {
+        if (this.hasPlugin('discardBinding') && this.match(84)) {
             prop.argument = this.parseVoidPattern(null);
             this.raise(Errors.UnexpectedVoidPattern, prop.argument);
         } else {
@@ -24792,13 +24776,13 @@ var LValParser = class extends NodeUtils {
     parseBindingProperty() {
         const {type, startLoc} = this.state;
         
-        if (type === 21) {
+        if (type === 17) {
             return this.parseBindingRestProperty(this.startNode());
         }
         
         const prop = this.startNode();
         
-        if (type === 139) {
+        if (type === 134) {
             this.expectPlugin('destructuringPrivate', startLoc);
             this.classScope.usePrivateName(this.state.value, startLoc);
             prop.key = this.parsePrivateName();
@@ -24835,7 +24819,7 @@ var LValParser = class extends NodeUtils {
         startLoc ?? (startLoc = this.state.startLoc);
         left = left ?? this.parseBindingAtom();
         
-        if (!this.eat(29))
+        if (!this.eat(25))
             return left;
         
         const node = this.startNodeAt(startLoc);
@@ -25017,7 +25001,7 @@ var LValParser = class extends NodeUtils {
     }
     
     checkCommaAfterRest(close) {
-        if (!this.match(12)) {
+        if (!this.match(8)) {
             return false;
         }
         
@@ -25226,10 +25210,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsTokenCanFollowModifier() {
         return this.match(0)
-            || this.match(5)
-            || this.match(55)
-            || this.match(21)
-            || this.match(139)
+            || this.match(2)
+            || this.match(51)
+            || this.match(17)
+            || this.match(134)
             || this.isLiteralPropertyName();
     }
     
@@ -25244,7 +25228,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsNextTokenCanFollowModifier() {
-        if (this.match(106)) {
+        if (this.match(102)) {
             this.next();
             return this.tsTokenCanFollowModifier();
         }
@@ -25253,14 +25237,14 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
-        if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
+        if (!tokenIsIdentifier(this.state.type) && this.state.type !== 54 && this.state.type !== 71) {
             return void 0;
         }
         
         const modifier = this.state.value;
         
         if (allowedModifiers.includes(modifier)) {
-            if (hasSeenStaticModifier && this.match(106)) {
+            if (hasSeenStaticModifier && this.match(102)) {
                 return void 0;
             }
             
@@ -25350,16 +25334,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         switch(kind) {
         case 'EnumMembers':        
         case 'TypeMembers':
-            return this.match(8);
+            return this.match(4);
         
         case 'HeritageClauseElement':
-            return this.match(5);
+            return this.match(2);
         
         case 'TupleElementTypes':
-            return this.match(3);
+            return this.match(1);
         
         case 'TypeParametersOrArguments':
-            return this.match(48);
+            return this.match(44);
         }
     }
     
@@ -25400,7 +25384,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             
             result.push(element);
             
-            if (this.eat(12)) {
+            if (this.eat(8)) {
                 trailingCommaPos = this.state.lastTokStartLoc.index;
                 continue;
             }
@@ -25410,7 +25394,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             }
             
             if (expectSuccess) {
-                this.expect(12);
+                this.expect(8);
             }
             
             return void 0;
@@ -25428,16 +25412,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             if (bracket) {
                 this.expect(0);
             } else {
-                this.expect(47);
+                this.expect(43);
             }
         }
         
         const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
         
         if (bracket) {
-            this.expect(3);
+            this.expect(1);
         } else {
-            this.expect(48);
+            this.expect(44);
         }
         
         return result;
@@ -25445,29 +25429,29 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseImportType() {
         const node = this.startNode();
-        this.expect(83);
-        this.expect(10);
+        this.expect(79);
+        this.expect(6);
         
-        if (!this.match(134)) {
+        if (!this.match(130)) {
             this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
             node.source = this.tsParseNonConditionalType();
         } else {
             node.source = this.parseStringLiteral(this.state.value);
         }
         
-        if (this.eat(12)) {
+        if (this.eat(8)) {
             node.options = this.tsParseImportTypeOptions();
         } else {
             node.options = null;
         }
         
-        this.expect(11);
+        this.expect(7);
         
-        if (this.eat(16)) {
+        if (this.eat(12)) {
             node.qualifier = this.tsParseEntityName(1 | 2);
         }
         
-        if (this.match(47)) {
+        if (this.match(43)) {
             node.typeArguments = this.tsParseTypeArguments();
         }
         
@@ -25476,42 +25460,42 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseImportTypeOptions() {
         const node = this.startNode();
-        this.expect(5);
+        this.expect(2);
         const withProperty = this.startNode();
         
-        if (this.isContextual(76)) {
+        if (this.isContextual(72)) {
             withProperty.method = false;
             withProperty.key = this.parseIdentifier(true);
             withProperty.computed = false;
             withProperty.shorthand = false;
         } else {
-            this.unexpected(null, 76);
+            this.unexpected(null, 72);
         }
         
-        this.expect(14);
+        this.expect(10);
         withProperty.value = this.tsParseImportTypeWithPropertyValue();
         node.properties = [
             this.finishObjectProperty(withProperty),
         ];
-        this.eat(12);
-        this.expect(8);
+        this.eat(8);
+        this.expect(4);
         return this.finishNode(node, 'ObjectExpression');
     }
     
     tsParseImportTypeWithPropertyValue() {
         const node = this.startNode();
         const properties = [];
-        this.expect(5);
-        while (!this.match(8)) {
+        this.expect(2);
+        while (!this.match(4)) {
             const type = this.state.type;
             
-            if (tokenIsIdentifier(type) || type === 134) {
+            if (tokenIsIdentifier(type) || type === 130) {
                 properties.push(super.parsePropertyDefinition(null));
             } else {
                 this.unexpected();
             }
             
-            this.eat(12);
+            this.eat(8);
         }
         
         node.properties = properties;
@@ -25522,7 +25506,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseEntityName(flags) {
         let entity;
         
-        if (flags & 1 && this.match(78)) {
+        if (flags & 1 && this.match(74)) {
             if (flags & 2) {
                 entity = this.parseIdentifier(true);
             } else {
@@ -25534,7 +25518,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             entity = this.parseIdentifier(!!(flags & 1));
         }
         
-        while (this.eat(16)) {
+        while (this.eat(12)) {
             const node = this.startNodeAtNode(entity);
             
             node.left = entity;
@@ -25550,7 +25534,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         node.typeName = this.tsParseEntityName(1);
         
-        if (!this.hasPrecedingLineBreak() && this.match(47)) {
+        if (!this.hasPrecedingLineBreak() && this.match(43)) {
             node.typeArguments = this.tsParseTypeArguments();
         }
         
@@ -25575,15 +25559,15 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseTypeQuery() {
         const node = this.startNode();
-        this.expect(87);
+        this.expect(83);
         
-        if (this.match(83)) {
+        if (this.match(79)) {
             node.exprName = this.tsParseImportType();
         } else {
             node.exprName = this.tsParseEntityName(1);
         }
         
-        if (!this.hasPrecedingLineBreak() && this.match(47)) {
+        if (!this.hasPrecedingLineBreak() && this.match(43)) {
             node.typeArguments = this.tsParseTypeArguments();
         }
         
@@ -25594,13 +25578,13 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         const node = this.startNode();
         parseModifiers(node);
         node.name = this.tsParseTypeParameterName();
-        node.constraint = this.tsEatThenParseType(81);
-        node.default = this.tsEatThenParseType(29);
+        node.constraint = this.tsEatThenParseType(77);
+        node.default = this.tsEatThenParseType(25);
         return this.finishNode(node, 'TSTypeParameter');
     }
     
     tsTryParseTypeParameters(parseModifiers) {
-        if (this.match(47)) {
+        if (this.match(43)) {
             return this.tsParseTypeParameters(parseModifiers);
         }
     }
@@ -25608,7 +25592,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseTypeParameters(parseModifiers) {
         const node = this.startNode();
         
-        if (this.match(47) || this.match(143)) {
+        if (this.match(43) || this.match(138)) {
             this.next();
         } else {
             this.unexpected();
@@ -25635,12 +25619,12 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsFillSignature(returnToken, signature) {
-        const returnTokenRequired = returnToken === 19;
+        const returnTokenRequired = returnToken === 15;
         const paramsKey = 'params';
         const returnTypeKey = 'returnType';
         
         signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
-        this.expect(10);
+        this.expect(6);
         signature[paramsKey] = this.tsParseBindingListForSignature();
         
         if (returnTokenRequired) {
@@ -25651,7 +25635,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseBindingListForSignature() {
-        const list = super.parseBindingList(11, 41, 2);
+        const list = super.parseBindingList(7, 41, 2);
         
         for (const pattern of list) {
             const {type} = pattern;
@@ -25667,13 +25651,13 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseTypeMemberSemicolon() {
-        if (!this.eat(12) && !this.isLineTerminator()) {
-            this.expect(13);
+        if (!this.eat(8) && !this.isLineTerminator()) {
+            this.expect(9);
         }
     }
     
     tsParseSignatureMember(kind, node) {
-        this.tsFillSignature(14, node);
+        this.tsFillSignature(10, node);
         this.tsParseTypeMemberSemicolon();
         return this.finishNode(node, kind);
     }
@@ -25683,7 +25667,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         if (tokenIsIdentifier(this.state.type)) {
             this.next();
-            return this.match(14);
+            return this.match(10);
         }
         
         return false;
@@ -25699,7 +25683,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         id.typeAnnotation = this.tsParseTypeAnnotation();
         this.resetEndLocation(id);
-        this.expect(3);
+        this.expect(1);
         node.parameters = [id];
         const type = this.tsTryParseTypeAnnotation();
         
@@ -25711,38 +25695,36 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParsePropertyOrMethodSignature(node, readonly) {
-        if (this.eat(17))
+        if (this.eat(13))
             node.optional = true;
         
-        if (this.match(10) || this.match(47)) {
+        if (this.match(6) || this.match(43)) {
             if (readonly) {
                 this.raise(TSErrors.ReadonlyForMethodSignature, node);
             }
             
             const method = node;
             
-            if (method.kind && this.match(47)) {
+            if (method.kind && this.match(43)) {
                 this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition());
             }
             
-            this.tsFillSignature(14, method);
+            this.tsFillSignature(10, method);
             this.tsParseTypeMemberSemicolon();
-            const paramsKey = 'params';
-            const returnTypeKey = 'returnType';
             
             if (method.kind === 'get') {
-                if (method[paramsKey].length > 0) {
+                if (method.params.length > 0) {
                     this.raise(Errors.BadGetterArity, this.state.curPosition());
                     
-                    if (this.isThisParam(method[paramsKey][0])) {
+                    if (this.isThisParam(method.params[0])) {
                         this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
                     }
                 }
             } else if (method.kind === 'set') {
-                if (method[paramsKey].length !== 1) {
+                if (method.params.length !== 1) {
                     this.raise(Errors.BadSetterArity, this.state.curPosition());
                 } else {
-                    const firstParameter = method[paramsKey][0];
+                    const firstParameter = method.params[0];
                     
                     if (this.isThisParam(firstParameter)) {
                         this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
@@ -25757,8 +25739,8 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                     }
                 }
                 
-                if (method[returnTypeKey]) {
-                    this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]);
+                if (method.returnType) {
+                    this.raise(TSErrors.SetAccessorCannotHaveReturnType, method.returnType);
                 }
             } else {
                 method.kind = 'method';
@@ -25784,15 +25766,15 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseTypeMember() {
         const node = this.startNode();
         
-        if (this.match(10) || this.match(47)) {
+        if (this.match(6) || this.match(43)) {
             return this.tsParseSignatureMember('TSCallSignatureDeclaration', node);
         }
         
-        if (this.match(77)) {
+        if (this.match(73)) {
             const id = this.startNode();
             this.next();
             
-            if (this.match(10) || this.match(47)) {
+            if (this.match(6) || this.match(43)) {
                 return this.tsParseSignatureMember('TSConstructSignatureDeclaration', node);
             } else {
                 node.key = this.createIdentifier(id, 'new');
@@ -25824,8 +25806,8 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             node.kind = node.key.name;
             super.parsePropertyName(node);
             
-            if (!this.match(10) && !this.match(47)) {
-                this.unexpected(null, 10);
+            if (!this.match(6) && !this.match(43)) {
+                this.unexpected(null, 6);
             }
         }
         
@@ -25840,20 +25822,20 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseObjectTypeMembers() {
-        this.expect(5);
+        this.expect(2);
         const members = this.tsParseList('TypeMembers', this.tsParseTypeMember.bind(this));
-        this.expect(8);
+        this.expect(4);
         return members;
     }
     
     tsIsStartOfMappedType() {
         this.next();
         
-        if (this.eat(53)) {
-            return this.isContextual(122);
+        if (this.eat(49)) {
+            return this.isContextual(118);
         }
         
-        if (this.isContextual(122)) {
+        if (this.isContextual(118)) {
             this.next();
         }
         
@@ -25868,38 +25850,38 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         }
         
         this.next();
-        return this.match(58);
+        return this.match(54);
     }
     
     tsParseMappedType() {
         const node = this.startNode();
-        this.expect(5);
+        this.expect(2);
         
-        if (this.match(53)) {
+        if (this.match(49)) {
             node.readonly = this.state.value;
             this.next();
-            this.expectContextual(122);
-        } else if (this.eatContextual(122)) {
+            this.expectContextual(118);
+        } else if (this.eatContextual(118)) {
             node.readonly = true;
         }
         
         this.expect(0);
         node.key = this.tsParseTypeParameterName();
-        node.constraint = this.tsExpectThenParseType(58);
-        node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
-        this.expect(3);
+        node.constraint = this.tsExpectThenParseType(54);
+        node.nameType = this.eatContextual(89) ? this.tsParseType() : null;
+        this.expect(1);
         
-        if (this.match(53)) {
+        if (this.match(49)) {
             node.optional = this.state.value;
             this.next();
-            this.expect(17);
-        } else if (this.eat(17)) {
+            this.expect(13);
+        } else if (this.eat(13)) {
             node.optional = true;
         }
         
         node.typeAnnotation = this.tsTryParseType();
         this.semicolon();
-        this.expect(8);
+        this.expect(4);
         return this.finishNode(node, 'TSMappedType');
     }
     
@@ -25923,7 +25905,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseTupleElementType() {
         const restStartLoc = this.state.startLoc;
-        const rest = this.eat(21);
+        const rest = this.eat(17);
         const {startLoc} = this.state;
         
         let labeled;
@@ -25937,7 +25919,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             labeled = true;
             optional = false;
             label = this.parseIdentifier(true);
-            this.expect(14);
+            this.expect(10);
             type = this.tsParseType();
         } else if (chAfterWord === 63) {
             optional = true;
@@ -25947,18 +25929,18 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             if (this.lookaheadCharCode() === 58) {
                 labeled = true;
                 label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
-                this.expect(17);
-                this.expect(14);
+                this.expect(13);
+                this.expect(10);
                 type = this.tsParseType();
             } else {
                 labeled = false;
                 type = typeOrLabel;
-                this.expect(17);
+                this.expect(13);
             }
         } else {
             type = this.tsParseType();
-            optional = this.eat(17);
-            labeled = this.eat(14);
+            optional = this.eat(13);
+            labeled = this.eat(10);
         }
         
         if (labeled) {
@@ -25970,7 +25952,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 labeledNode.label = label;
                 labeledNode.elementType = type;
                 
-                if (this.eat(17)) {
+                if (this.eat(13)) {
                     labeledNode.optional = true;
                     this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);
                 }
@@ -26002,9 +25984,9 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseParenthesizedType() {
         const node = this.startNode();
-        this.expect(10);
+        this.expect(6);
         node.typeAnnotation = this.tsParseType();
-        this.expect(11);
+        this.expect(7);
         return this.finishNode(node, 'TSParenthesizedType');
     }
     
@@ -26020,7 +26002,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             this.next();
         }
         
-        this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
+        this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(15, node));
         return this.finishNode(node, type);
     }
     
@@ -26028,11 +26010,11 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         const node = this.startNode();
         
         switch(this.state.type) {
-        case 135:        
-        case 136:        
-        case 134:        
-        case 85:        
-        case 86:
+        case 131:        
+        case 132:        
+        case 130:        
+        case 81:        
+        case 82:
             node.literal = super.parseExprAtom();
             break;
         
@@ -26084,7 +26066,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseThisTypeOrThisTypePredicate() {
         const thisKeyword = this.tsParseThisTypeNode();
         
-        if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
+        if (this.isContextual(112) && !this.hasPrecedingLineBreak()) {
             return this.tsParseThisTypePredicate(thisKeyword);
         } else {
             return thisKeyword;
@@ -26093,19 +26075,19 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseNonArrayType() {
         switch(this.state.type) {
-        case 134:        
-        case 135:        
-        case 136:        
-        case 85:        
-        case 86:
+        case 130:        
+        case 131:        
+        case 132:        
+        case 81:        
+        case 82:
             return this.tsParseLiteralTypeNode();
         
-        case 53:
+        case 49:
             if (this.state.value === '-') {
                 const node = this.startNode();
                 const nextToken = this.lookahead();
                 
-                if (nextToken.type !== 135 && nextToken.type !== 136) {
+                if (nextToken.type !== 131 && nextToken.type !== 132) {
                     this.unexpected();
                 }
                 
@@ -26115,27 +26097,27 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             
             break;
         
-        case 78:
+        case 74:
             return this.tsParseThisTypeOrThisTypePredicate();
         
-        case 87:
+        case 83:
             return this.tsParseTypeQuery();
         
-        case 83:
+        case 79:
             return this.tsParseImportType();
         
-        case 5:
+        case 2:
             return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
         
         case 0:
             return this.tsParseTupleType();
         
-        case 10:
+        case 6:
             if (!(this.optionFlags & 1024)) {
                 const startLoc = this.state.startLoc;
                 this.next();
                 const type = this.tsParseType();
-                this.expect(11);
+                this.expect(7);
                 this.addExtra(type, 'parenthesized', true);
                 this.addExtra(type, 'parenStart', startLoc.index);
                 return type;
@@ -26143,15 +26125,15 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             
             return this.tsParseParenthesizedType();
         
-        case 25:        
-        case 24:
+        case 21:        
+        case 20:
             return this.tsParseTemplateLiteralType();
         
         default: {
             const {type} = this.state;
             
-            if (tokenIsIdentifier(type) || type === 88 || type === 84) {
-                const nodeType = type === 88 ? 'TSVoidKeyword' : type === 84 ? 'TSNullKeyword' : keywordTypeFromName(this.state.value);
+            if (tokenIsIdentifier(type) || type === 84 || type === 80) {
+                const nodeType = type === 84 ? 'TSVoidKeyword' : type === 80 ? 'TSNullKeyword' : keywordTypeFromName(this.state.value);
                 
                 if (nodeType !== void 0 && this.lookaheadCharCode() !== 46) {
                     const node = this.startNode();
@@ -26173,18 +26155,18 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         let type = this.tsParseNonArrayType();
         
         while (!this.hasPrecedingLineBreak() && this.eat(0)) {
-            if (this.match(3)) {
+            if (this.match(1)) {
                 const node = this.startNodeAt(startLoc);
                 
                 node.elementType = type;
-                this.expect(3);
+                this.expect(1);
                 type = this.finishNode(node, 'TSArrayType');
             } else {
                 const node = this.startNodeAt(startLoc);
                 
                 node.objectType = type;
                 node.indexType = this.tsParseType();
-                this.expect(3);
+                this.expect(1);
                 type = this.finishNode(node, 'TSIndexedAccessType');
             }
         }
@@ -26219,7 +26201,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseInferType() {
         const node = this.startNode();
-        this.expectContextual(115);
+        this.expectContextual(111);
         const typeParameter2 = this.startNode();
         
         typeParameter2.name = this.tsParseTypeParameterName();
@@ -26229,10 +26211,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseConstraintForInferType() {
-        if (this.eat(81)) {
+        if (this.eat(77)) {
             const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
             
-            if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
+            if (this.state.inDisallowConditionalTypesContext || !this.match(13)) {
                 return constraint;
             }
         }
@@ -26240,7 +26222,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseTypeOperatorOrHigher() {
         const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
-        return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
+        return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(111) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
     }
     
     tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
@@ -26260,34 +26242,34 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseIntersectionTypeOrHigher() {
-        return this.tsParseUnionOrIntersectionType('TSIntersectionType', this.tsParseTypeOperatorOrHigher.bind(this), 45);
+        return this.tsParseUnionOrIntersectionType('TSIntersectionType', this.tsParseTypeOperatorOrHigher.bind(this), 41);
     }
     
     tsParseUnionTypeOrHigher() {
-        return this.tsParseUnionOrIntersectionType('TSUnionType', this.tsParseIntersectionTypeOrHigher.bind(this), 43);
+        return this.tsParseUnionOrIntersectionType('TSUnionType', this.tsParseIntersectionTypeOrHigher.bind(this), 39);
     }
     
     tsIsStartOfFunctionType() {
-        if (this.match(47)) {
+        if (this.match(43)) {
             return true;
         }
         
-        return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
+        return this.match(6) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
     }
     
     tsSkipParameterStart() {
-        if (tokenIsIdentifier(this.state.type) || this.match(78)) {
+        if (tokenIsIdentifier(this.state.type) || this.match(74)) {
             this.next();
             return true;
         }
         
-        if (this.match(5)) {
+        if (this.match(2)) {
             const {errors} = this.state;
             
             const previousErrorCount = errors.length;
             
             try {
-                this.parseObjectLike(8, true);
+                this.parseObjectLike(4, true);
                 return errors.length === previousErrorCount;
             } catch {
                 return false;
@@ -26301,7 +26283,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             const previousErrorCount = errors.length;
             
             try {
-                super.parseBindingList(3, 93, 1);
+                super.parseBindingList(1, 93, 1);
                 return errors.length === previousErrorCount;
             } catch {
                 return false;
@@ -26314,19 +26296,19 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsIsUnambiguouslyStartOfFunctionType() {
         this.next();
         
-        if (this.match(11) || this.match(21)) {
+        if (this.match(7) || this.match(17)) {
             return true;
         }
         
         if (this.tsSkipParameterStart()) {
-            if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {
+            if (this.match(10) || this.match(8) || this.match(13) || this.match(25)) {
                 return true;
             }
             
-            if (this.match(11)) {
+            if (this.match(7)) {
                 this.next();
                 
-                if (this.match(19)) {
+                if (this.match(15)) {
                     return true;
                 }
             }
@@ -26342,7 +26324,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             const node = this.startNode();
             const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
             
-            if (asserts && this.match(78)) {
+            if (asserts && this.match(74)) {
                 let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
                 
                 if (thisTypePredicate.type === 'TSThisType') {
@@ -26384,39 +26366,39 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsTryParseTypeOrTypePredicateAnnotation() {
-        if (this.match(14)) {
-            return this.tsParseTypeOrTypePredicateAnnotation(14);
+        if (this.match(10)) {
+            return this.tsParseTypeOrTypePredicateAnnotation(10);
         }
     }
     
     tsTryParseTypeAnnotation() {
-        if (this.match(14)) {
+        if (this.match(10)) {
             return this.tsParseTypeAnnotation();
         }
     }
     
     tsTryParseType() {
-        return this.tsEatThenParseType(14);
+        return this.tsEatThenParseType(10);
     }
     
     tsParseTypePredicatePrefix() {
         const id = this.parseIdentifier();
         
-        if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
+        if (this.isContextual(112) && !this.hasPrecedingLineBreak()) {
             this.next();
             return id;
         }
     }
     
     tsParseTypePredicateAsserts() {
-        if (this.state.type !== 109) {
+        if (this.state.type !== 105) {
             return false;
         }
         
         const containsEsc = this.state.containsEsc;
         this.next();
         
-        if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
+        if (!tokenIsIdentifier(this.state.type) && !this.match(74)) {
             return false;
         }
         
@@ -26432,7 +26414,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
         this.tsInType(() => {
             if (eatColon)
-                this.expect(14);
+                this.expect(10);
             
             t.typeAnnotation = this.tsParseType();
         });
@@ -26443,7 +26425,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         assert2(this.state.inType);
         const type = this.tsParseNonConditionalType();
         
-        if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
+        if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(77)) {
             return type;
         }
         
@@ -26451,15 +26433,15 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         node.checkType = type;
         node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
-        this.expect(17);
+        this.expect(13);
         node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
-        this.expect(14);
+        this.expect(10);
         node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
         return this.finishNode(node, 'TSConditionalType');
     }
     
     isAbstractConstructorSignature() {
-        return this.isContextual(124) && this.isLookaheadContextual('new');
+        return this.isContextual(120) && this.isLookaheadContextual('new');
     }
     
     tsParseNonConditionalType() {
@@ -26467,7 +26449,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             return this.tsParseFunctionOrConstructorType('TSFunctionType');
         }
         
-        if (this.match(77)) {
+        if (this.match(73)) {
             return this.tsParseFunctionOrConstructorType('TSConstructorType');
         } else if (this.isAbstractConstructorSignature()) {
             return this.tsParseFunctionOrConstructorType('TSConstructorType', true);
@@ -26485,9 +26467,9 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         node.typeAnnotation = this.tsInType(() => {
             this.next();
-            return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
+            return this.match(71) ? this.tsParseTypeReference() : this.tsParseType();
         });
-        this.expect(48);
+        this.expect(44);
         node.expression = this.parseMaybeUnary();
         return this.finishNode(node, 'TSTypeAssertion');
     }
@@ -26514,7 +26496,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             
             node.expression = expression2;
             
-            if (this.match(47) || this.match(51)) {
+            if (this.match(43) || this.match(47)) {
                 node.typeArguments = this.tsParseTypeArgumentsInExpression();
             }
             
@@ -26534,7 +26516,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         if (this.hasFollowingLineBreak())
             return null;
         
-        this.expectContextual(129);
+        this.expectContextual(125);
         
         if (properties.declare)
             node.declare = true;
@@ -26549,7 +26531,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
         
-        if (this.eat(81)) {
+        if (this.eat(77)) {
             node.extends = this.tsParseHeritageClause('extends');
         }
         
@@ -26565,9 +26547,9 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         this.checkIdentifier(node.id, 2);
         node.typeAnnotation = this.tsInType(() => {
             node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
-            this.expect(29);
+            this.expect(25);
             
-            if (this.isContextual(114) && this.lookaheadCharCode() !== 46) {
+            if (this.isContextual(110) && this.lookaheadCharCode() !== 46) {
                 const node2 = this.startNode();
                 this.next();
                 return this.finishNode(node2, 'TSIntrinsicKeyword');
@@ -26650,9 +26632,9 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseEnumMember() {
         const node = this.startNode();
         
-        node.id = this.match(134) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
+        node.id = this.match(130) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
         
-        if (this.eat(29)) {
+        if (this.eat(25)) {
             node.initializer = super.parseMaybeAssignAllowIn();
         }
         
@@ -26666,7 +26648,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         if (properties.declare)
             node.declare = true;
         
-        this.expectContextual(126);
+        this.expectContextual(122);
         node.id = this.parseIdentifier();
         this.checkIdentifier(node.id, node.const ? 8971 : 8459);
         node.body = this.tsParseEnumBody();
@@ -26675,17 +26657,17 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseEnumBody() {
         const node = this.startNode();
-        this.expect(5);
+        this.expect(2);
         node.members = this.tsParseDelimitedList('EnumMembers', this.tsParseEnumMember.bind(this));
-        this.expect(8);
+        this.expect(4);
         return this.finishNode(node, 'TSEnumBody');
     }
     
     tsParseModuleBlock() {
         const node = this.startNode();
         this.scope.enter(0);
-        this.expect(5);
-        super.parseBlockOrModuleBlockBody(node.body = [], void 0, true, 8);
+        this.expect(2);
+        super.parseBlockOrModuleBlockBody(node.body = [], void 0, true, 4);
         this.scope.exit();
         return this.finishNode(node, 'TSModuleBlock');
     }
@@ -26706,17 +26688,17 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseAmbientExternalModuleDeclaration(node) {
-        if (this.isContextual(112)) {
+        if (this.isContextual(108)) {
             node.kind = 'global';
             node.id = this.parseIdentifier();
-        } else if (this.match(134)) {
+        } else if (this.match(130)) {
             node.kind = 'module';
             node.id = super.parseStringLiteral(this.state.value);
         } else {
             this.unexpected();
         }
         
-        if (this.match(5)) {
+        if (this.match(2)) {
             this.scope.enter(1024);
             this.prodParam.enter(0);
             node.body = this.tsParseModuleBlock();
@@ -26732,7 +26714,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier) {
         node.id = maybeDefaultIdentifier || this.parseIdentifier();
         this.checkIdentifier(node.id, 4096);
-        this.expect(29);
+        this.expect(25);
         const moduleReference = this.tsParseModuleReference();
         
         if (node.importKind === 'type' && moduleReference.type !== 'TSExternalModuleReference') {
@@ -26745,7 +26727,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsIsExternalModuleReference() {
-        return this.isContextual(119) && this.lookaheadCharCode() === 40;
+        return this.isContextual(115) && this.lookaheadCharCode() === 40;
     }
     
     tsParseModuleReference() {
@@ -26754,15 +26736,15 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseExternalModuleReference() {
         const node = this.startNode();
-        this.expectContextual(119);
-        this.expect(10);
+        this.expectContextual(115);
+        this.expect(6);
         
-        if (!this.match(134)) {
+        if (!this.match(130)) {
             this.unexpected();
         }
         
         node.expression = super.parseExprAtom();
-        this.expect(11);
+        this.expect(7);
         this.sawUnambiguousESM = true;
         return this.finishNode(node, 'TSExternalModuleReference');
     }
@@ -26807,41 +26789,41 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         return this.tsInAmbientContext(() => {
             switch(startType) {
-            case 68:
+            case 64:
                 node.declare = true;
                 return super.parseFunctionStatement(node, false, false);
             
-            case 80:
+            case 76:
                 node.declare = true;
                 return this.parseClass(node, true, false);
             
-            case 126:
+            case 122:
                 return this.tsParseEnumDeclaration(node, {
                     declare: true,
                 });
             
-            case 112:
+            case 108:
                 return this.tsParseAmbientExternalModuleDeclaration(node);
             
-            case 100:
+            case 96:
                 if (this.state.containsEsc) {
                     return;
                 }
             
-            case 75:            
-            case 74:
-                if (!this.match(75) || !this.isLookaheadContextual('enum')) {
+            case 71:            
+            case 70:
+                if (!this.match(71) || !this.isLookaheadContextual('enum')) {
                     node.declare = true;
                     return this.parseVarStatement(node, this.state.value, true);
                 }
                 
-                this.expect(75);
+                this.expect(71);
                 return this.tsParseEnumDeclaration(node, {
                     const: true,
                     declare: true,
                 });
             
-            case 107:
+            case 103:
                 if (this.isUsing()) {
                     this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, 'declare');
                     node.declare = true;
@@ -26850,7 +26832,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 
                 break;
             
-            case 96:
+            case 92:
                 if (this.isAwaitUsing()) {
                     this.raise(TSErrors.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, 'declare');
                     node.declare = true;
@@ -26860,7 +26842,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 
                 break;
             
-            case 129: {
+            case 125: {
                 const result = this.tsParseInterfaceDeclaration(node, {
                     declare: true,
                 });
@@ -26883,16 +26865,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     tsParseDeclaration(node, type, next, decorators) {
         switch(type) {
-        case 124:
-            if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
+        case 120:
+            if (this.tsCheckLineTerminator(next) && (this.match(76) || tokenIsIdentifier(this.state.type))) {
                 return this.tsParseAbstractDeclaration(node, decorators);
             }
             
             break;
         
-        case 127:
+        case 123:
             if (this.tsCheckLineTerminator(next)) {
-                if (this.match(134)) {
+                if (this.match(130)) {
                     return this.tsParseAmbientExternalModuleDeclaration(node);
                 } else if (tokenIsIdentifier(this.state.type)) {
                     node.kind = 'module';
@@ -26902,7 +26884,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             
             break;
         
-        case 128:
+        case 124:
             if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
                 node.kind = 'namespace';
                 return this.tsParseModuleOrNamespaceDeclaration(node);
@@ -26910,7 +26892,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             
             break;
         
-        case 130:
+        case 126:
             if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
                 return this.tsParseTypeAliasDeclaration(node);
             }
@@ -26932,7 +26914,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsTryParseGenericAsyncArrowFunction(startLoc) {
-        if (!this.match(47))
+        if (!this.match(43))
             return;
         
         const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
@@ -26944,7 +26926,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
             super.parseFunctionParams(node);
             node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
-            this.expect(19);
+            this.expect(15);
             return node;
         });
         
@@ -26957,7 +26939,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseTypeArgumentsInExpression() {
-        if (this.reScan_lt() !== 47)
+        if (this.reScan_lt() !== 43)
             return;
         
         return this.tsParseTypeArguments();
@@ -26967,7 +26949,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         const node = this.startNode();
         
         node.params = this.tsInType(() => this.tsInTopLevelContext(() => {
-            this.expect(47);
+            this.expect(43);
             return this.tsParseDelimitedList('TypeParametersOrArguments', this.tsParseType.bind(this));
         }));
         
@@ -26977,7 +26959,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             this.reScan_lt_gt();
         }
         
-        this.expect(48);
+        this.expect(44);
         return this.finishNode(node, 'TSTypeParameterInstantiation');
     }
     
@@ -27070,13 +27052,13 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseFunctionBodyAndFinish(node, type, isMethod3 = false) {
-        if (this.match(14)) {
-            node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
+        if (this.match(10)) {
+            node.returnType = this.tsParseTypeOrTypePredicateAnnotation(10);
         }
         
         const bodilessType = type === 'FunctionDeclaration' ? 'TSDeclareFunction' : type === 'ClassMethod' || type === 'ClassPrivateMethod' ? 'TSDeclareMethod' : void 0;
         
-        if (bodilessType && !this.match(5) && this.isLineTerminator()) {
+        if (bodilessType && !this.match(2) && this.isLineTerminator()) {
             return this.finishNode(node, bodilessType);
         }
         
@@ -27124,7 +27106,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseSubscript(base, startLoc, noCalls, state) {
-        if (!this.hasPrecedingLineBreak() && this.match(35)) {
+        if (!this.hasPrecedingLineBreak() && this.match(31)) {
             this.state.canStartJSXElement = false;
             this.next();
             const nonNullExpression = this.startNodeAt(startLoc);
@@ -27135,7 +27117,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         let isOptionalCall = false;
         
-        if (this.match(18) && this.lookaheadCharCode() === 60) {
+        if (this.match(14) && this.lookaheadCharCode() === 60) {
             if (noCalls) {
                 state.stop = true;
                 return base;
@@ -27146,7 +27128,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             this.next();
         }
         
-        if (this.match(47) || this.match(51)) {
+        if (this.match(43) || this.match(47)) {
             let missingParenErrorLoc;
             const result = this.tsTryParseAndCatch(() => {
                 if (!noCalls && this.atPossibleAsyncArrow(base)) {
@@ -27163,7 +27145,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 if (!typeArguments)
                     return;
                 
-                if (isOptionalCall && !this.match(10)) {
+                if (isOptionalCall && !this.match(6)) {
                     missingParenErrorLoc = this.state.curPosition();
                     return;
                 }
@@ -27175,7 +27157,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                     return result2;
                 }
                 
-                if (!noCalls && this.eat(10)) {
+                if (!noCalls && this.eat(6)) {
                     const node2 = this.startNodeAt(startLoc);
                     
                     node2.callee = base;
@@ -27192,7 +27174,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 
                 const tokenType = this.state.type;
                 
-                if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
+                if (tokenType === 44 || tokenType === 48 || tokenType !== 6 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
                     return;
                 }
                 
@@ -27204,16 +27186,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             });
             
             if (missingParenErrorLoc) {
-                this.unexpected(missingParenErrorLoc, 10);
+                this.unexpected(missingParenErrorLoc, 6);
             }
             
             if (result) {
                 if (result.type === 'TSInstantiationExpression') {
-                    if (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40) {
+                    if (this.match(12) || this.match(14) && this.lookaheadCharCode() !== 40) {
                         this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);
                     }
                     
-                    if (!this.match(16) && !this.match(18)) {
+                    if (!this.match(12) && !this.match(14)) {
                         result.expression = super.stopParseSubscript(base, state);
                     }
                 }
@@ -27238,14 +27220,14 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseExprOp(left, leftStartLoc, minPrec) {
         let isSatisfies;
         
-        if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) {
+        if (tokenOperatorPrecedence(54) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(89) || (isSatisfies = this.isContextual(116)))) {
             const node = this.startNodeAt(leftStartLoc);
             
             node.expression = left;
             node.typeAnnotation = this.tsInType(() => {
                 this.next();
                 
-                if (this.match(75)) {
+                if (this.match(71)) {
                     if (isSatisfies) {
                         this.raise(Errors.UnexpectedKeyword, this.state.startLoc, {
                             keyword: 'const',
@@ -27277,12 +27259,12 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         if (super.isPotentialImportPhase(isExport))
             return true;
         
-        if (this.isContextual(130)) {
+        if (this.isContextual(126)) {
             const ch = this.lookaheadCharCode();
             return isExport ? ch === 123 || ch === 42 : ch !== 61;
         }
         
-        return !isExport && this.isContextual(87);
+        return !isExport && this.isContextual(83);
     }
     
     applyImportPhase(node, isExport, phase, loc) {
@@ -27296,7 +27278,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseImport(node) {
-        if (this.match(134)) {
+        if (this.match(130)) {
             node.importKind = 'value';
             return super.parseImport(node);
         }
@@ -27306,7 +27288,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
             node.importKind = 'value';
             return this.tsParseImportEqualsDeclaration(node);
-        } else if (this.isContextual(130)) {
+        } else if (this.isContextual(126)) {
             const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
             
             if (this.lookaheadCharCode() === 61) {
@@ -27326,12 +27308,12 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseExport(node, decorators) {
-        if (this.match(83)) {
+        if (this.match(79)) {
             const nodeImportEquals = this.startNode();
             this.next();
             let maybeDefaultIdentifier = null;
             
-            if (this.isContextual(130) && this.isPotentialImportPhase(false)) {
+            if (this.isContextual(126) && this.isPotentialImportPhase(false)) {
                 maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
             } else {
                 nodeImportEquals.importKind = 'value';
@@ -27345,16 +27327,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             node.source = null;
             node.specifiers = [];
             return this.finishNode(node, 'ExportNamedDeclaration');
-        } else if (this.eat(29)) {
+        } else if (this.eat(25)) {
             const assign = node;
             
             assign.expression = super.parseExpression();
             this.semicolon();
             this.sawUnambiguousESM = true;
             return this.finishNode(assign, 'TSExportAssignment');
-        } else if (this.eatContextual(93)) {
+        } else if (this.eatContextual(89)) {
             const decl = node;
-            this.expectContextual(128);
+            this.expectContextual(124);
             decl.id = this.parseIdentifier();
             this.semicolon();
             return this.finishNode(decl, 'TSNamespaceExportDeclaration');
@@ -27365,7 +27347,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     isAbstractClass() {
-        return this.isContextual(124) && this.isLookaheadContextual('class');
+        return this.isContextual(120) && this.isLookaheadContextual('class');
     }
     
     parseExportDefaultExpression() {
@@ -27376,7 +27358,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             return this.parseClass(cls, true, true);
         }
         
-        if (this.match(129)) {
+        if (this.match(125)) {
             const result = this.tsParseInterfaceDeclaration(this.startNode());
             
             if (result)
@@ -27416,10 +27398,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseStatementContent(flags, decorators) {
         if (!this.state.containsEsc) {
             switch(this.state.type) {
-            case 75: {
+            case 71: {
                 if (this.isLookaheadContextual('enum')) {
                     const node = this.startNode();
-                    this.expect(75);
+                    this.expect(71);
                     return this.tsParseEnumDeclaration(node, {
                         const: true,
                     });
@@ -27428,22 +27410,22 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 break;
             }
             
-            case 124:            
-            case 125: {
+            case 120:            
+            case 121: {
                 if (this.nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine()) {
                     const token = this.state.type;
                     const node = this.startNode();
                     this.next();
-                    const declaration = token === 125 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators);
+                    const declaration = token === 121 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators);
                     
                     if (declaration) {
-                        if (token === 125) {
+                        if (token === 121) {
                             declaration.declare = true;
                         }
                         
                         return declaration;
                     } else {
-                        node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 125 ? 'declare' : 'abstract');
+                        node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 121 ? 'declare' : 'abstract');
                         this.semicolon(false);
                         return this.finishNode(node, 'ExpressionStatement');
                     }
@@ -27452,10 +27434,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 break;
             }
             
-            case 126:
+            case 122:
                 return this.tsParseEnumDeclaration(this.startNode());
             
-            case 112: {
+            case 108: {
                 const nextCh = this.lookaheadCharCode();
                 
                 if (nextCh === 123) {
@@ -27466,7 +27448,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 break;
             }
             
-            case 129: {
+            case 125: {
                 const result = this.tsParseInterfaceDeclaration(this.startNode());
                 
                 if (result)
@@ -27475,27 +27457,27 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 break;
             }
             
-            case 127: {
+            case 123: {
                 if (this.nextTokenIsIdentifierOrStringLiteralOnSameLine()) {
                     const node = this.startNode();
                     this.next();
-                    return this.tsParseDeclaration(node, 127, false, decorators);
+                    return this.tsParseDeclaration(node, 123, false, decorators);
                 }
                 
                 break;
             }
             
-            case 128: {
+            case 124: {
                 if (this.nextTokenIsIdentifierOnSameLine()) {
                     const node = this.startNode();
                     this.next();
-                    return this.tsParseDeclaration(node, 128, false, decorators);
+                    return this.tsParseDeclaration(node, 124, false, decorators);
                 }
                 
                 break;
             }
             
-            case 130: {
+            case 126: {
                 if (this.nextTokenIsIdentifierOnSameLine()) {
                     const node = this.startNode();
                     this.next();
@@ -27525,7 +27507,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsIsStartOfStaticBlocks() {
-        return this.isContextual(106) && this.lookaheadCharCode() === 123;
+        return this.isContextual(102) && this.lookaheadCharCode() === 123;
     }
     
     parseClassMember(classBody2, member, state) {
@@ -27609,16 +27591,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parsePostMemberNameModifiers(methodOrProp) {
-        const optional = this.eat(17);
+        const optional = this.eat(13);
         
         if (optional)
             methodOrProp.optional = true;
         
-        if (methodOrProp.readonly && this.match(10)) {
+        if (methodOrProp.readonly && this.match(6)) {
             this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);
         }
         
-        if (methodOrProp.declare && this.match(10)) {
+        if (methodOrProp.declare && this.match(6)) {
             this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);
         }
     }
@@ -27631,7 +27613,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseConditional(expr, startLoc, refExpressionErrors) {
-        if (!this.match(17))
+        if (!this.match(13))
             return expr;
         
         if (this.state.maybeInArrowParameters) {
@@ -27649,12 +27631,12 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseParenItem(node, startLoc) {
         const newNode = super.parseParenItem(node, startLoc);
         
-        if (this.eat(17)) {
+        if (this.eat(13)) {
             newNode.optional = true;
             this.resetEndLocation(node);
         }
         
-        if (this.match(14)) {
+        if (this.match(10)) {
             const typeCastNode = this.startNodeAt(startLoc);
             
             typeCastNode.expression = node;
@@ -27666,14 +27648,14 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseExportDeclaration(node) {
-        if (!this.state.isAmbientContext && this.isContextual(125)) {
+        if (!this.state.isAmbientContext && this.isContextual(121)) {
             return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
         }
         
         const startLoc = this.state.startLoc;
-        const isDeclare = this.eatContextual(125);
+        const isDeclare = this.eatContextual(121);
         
-        if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) {
+        if (isDeclare && (this.isContextual(121) || !this.shouldParseExportDeclaration())) {
             throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
         }
         
@@ -27696,7 +27678,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseClassId(node, isStatement5, optionalId) {
-        if ((!isStatement5 || optionalId) && this.isContextual(113)) {
+        if ((!isStatement5 || optionalId) && this.isContextual(109)) {
             return;
         }
         
@@ -27709,9 +27691,9 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     parseClassPropertyAnnotation(node) {
         if (!node.optional) {
-            if (this.eat(35)) {
+            if (this.eat(31)) {
                 node.definite = true;
-            } else if (this.eat(17)) {
+            } else if (this.eat(13)) {
                 node.optional = true;
             }
         }
@@ -27725,11 +27707,11 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseClassProperty(node) {
         this.parseClassPropertyAnnotation(node);
         
-        if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
+        if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(25)) {
             this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);
         }
         
-        if (node.abstract && this.match(29)) {
+        if (node.abstract && this.match(25)) {
             const {key} = node;
             
             this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, {
@@ -27809,11 +27791,11 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseClassSuper(node) {
         super.parseClassSuper(node);
         
-        if (node.superClass && (this.match(47) || this.match(51))) {
+        if (node.superClass && (this.match(43) || this.match(47))) {
             node.superTypeArguments = this.tsParseTypeArgumentsInExpression();
         }
         
-        if (this.eatContextual(113)) {
+        if (this.eatContextual(109)) {
             node.implements = this.tsParseHeritageClause('implements');
         }
     }
@@ -27839,7 +27821,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     parseVarId(decl, kind) {
         super.parseVarId(decl, kind);
         
-        if (decl.id.type === 'Identifier' && !this.hasPrecedingLineBreak() && this.eat(35)) {
+        if (decl.id.type === 'Identifier' && !this.hasPrecedingLineBreak() && this.eat(31)) {
             decl.definite = true;
         }
         
@@ -27852,7 +27834,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseAsyncArrowFromCallExpression(node, call2) {
-        if (this.match(14)) {
+        if (this.match(10)) {
             node.returnType = this.tsParseTypeAnnotation();
         }
         
@@ -27864,7 +27846,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         let jsx2;
         let typeCast;
         
-        if (this.hasPlugin('jsx') && (this.match(143) || this.match(47))) {
+        if (this.hasPlugin('jsx') && (this.match(138) || this.match(43))) {
             state = this.state.clone();
             jsx2 = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
             
@@ -27880,7 +27862,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             }
         }
         
-        if (!jsx2?.error && !this.match(47)) {
+        if (!jsx2?.error && !this.match(43)) {
             return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
         }
         
@@ -27960,7 +27942,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseMaybeUnary(refExpressionErrors, sawUnary) {
-        if (!this.hasPlugin('jsx') && this.match(47)) {
+        if (!this.hasPlugin('jsx') && this.match(43)) {
             return this.tsParseTypeAssertion();
         }
         
@@ -27968,11 +27950,11 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseArrow(node) {
-        if (this.match(14)) {
+        if (this.match(10)) {
             const result = this.tryParse((abort) => {
-                const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
+                const returnType = this.tsParseTypeOrTypePredicateAnnotation(10);
                 
-                if (this.canInsertSemicolon() || !this.match(19))
+                if (this.canInsertSemicolon() || !this.match(15))
                     abort();
                 
                 return returnType;
@@ -27993,7 +27975,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseFunctionParamType(param) {
-        if (this.eat(17)) {
+        if (this.eat(13)) {
             param.optional = true;
         }
         
@@ -28102,7 +28084,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseBindingAtom() {
-        if (this.state.type === 78) {
+        if (this.state.type === 74) {
             return this.parseIdentifier(true);
         }
         
@@ -28110,24 +28092,24 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseMaybeDecoratorArguments(expr, startLoc) {
-        if (this.match(47) || this.match(51)) {
+        if (this.match(43) || this.match(47)) {
             const typeArguments = this.tsParseTypeArgumentsInExpression();
             
-            if (this.match(10)) {
+            if (this.match(6)) {
                 const call2 = super.parseMaybeDecoratorArguments(expr, startLoc);
                 
                 call2.typeArguments = typeArguments;
                 return call2;
             }
             
-            this.unexpected(null, 10);
+            this.unexpected(null, 6);
         }
         
         return super.parseMaybeDecoratorArguments(expr, startLoc);
     }
     
     checkCommaAfterRest(close) {
-        if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
+        if (this.state.isAmbientContext && this.match(8) && this.lookaheadCharCode() === close) {
             this.next();
             return false;
         }
@@ -28136,11 +28118,11 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     isClassMethod() {
-        return this.match(47) || super.isClassMethod();
+        return this.match(43) || super.isClassMethod();
     }
     
     isClassProperty() {
-        return this.match(35) || this.match(14) || super.isClassProperty();
+        return this.match(31) || this.match(10) || super.isClassProperty();
     }
     
     parseMaybeDefault(startLoc, left) {
@@ -28156,12 +28138,12 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     getTokenFromCode(code2) {
         if (this.state.inType) {
             if (code2 === 62) {
-                this.finishOp(48, 1);
+                this.finishOp(44, 1);
                 return;
             }
             
             if (code2 === 60) {
-                this.finishOp(47, 1);
+                this.finishOp(43, 1);
                 return;
             }
         }
@@ -28172,10 +28154,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     reScan_lt_gt() {
         const {type} = this.state;
         
-        if (type === 47) {
+        if (type === 43) {
             this.state.pos -= 1;
             this.readToken_lt();
-        } else if (type === 48) {
+        } else if (type === 44) {
             this.state.pos -= 1;
             this.readToken_gt();
         }
@@ -28184,10 +28166,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     reScan_lt() {
         const {type} = this.state;
         
-        if (type === 51) {
+        if (type === 47) {
             this.state.pos -= 2;
-            this.finishOp(47, 1);
-            return 47;
+            this.finishOp(43, 1);
+            return 43;
         }
         
         return type;
@@ -28210,7 +28192,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     shouldParseArrow(params) {
-        if (this.match(14)) {
+        if (this.match(10)) {
             return params.every((expr) => this.isAssignable(expr, true));
         }
         
@@ -28218,7 +28200,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     shouldParseAsyncArrow() {
-        return this.match(14) || super.shouldParseAsyncArrow();
+        return this.match(10) || super.shouldParseAsyncArrow();
     }
     
     canHaveLeadingDecorator() {
@@ -28226,7 +28208,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     jsxParseOpeningElementAfterName(node) {
-        if (this.match(47) || this.match(51)) {
+        if (this.match(43) || this.match(47)) {
             const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
             
             if (typeArguments) {
@@ -28286,10 +28268,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseAbstractDeclaration(node, decorators) {
-        if (this.match(80)) {
+        if (this.match(76)) {
             node.abstract = true;
             return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
-        } else if (this.isContextual(129)) {
+        } else if (this.isContextual(125)) {
             if (!this.hasFollowingLineBreak()) {
                 node.abstract = true;
                 this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node);
@@ -28299,7 +28281,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             }
         }
         
-        throw this.unexpected(null, 80);
+        throw this.unexpected(null, 76);
     }
     
     parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
@@ -28322,8 +28304,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     tsParseTypeParameterName() {
-        const typeName = this.parseIdentifier();
-        return typeName;
+        return this.parseIdentifier();
     }
     
     shouldParseAsAmbientContext() {
@@ -28375,10 +28356,10 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         let canParseAsKeyword = true;
         const loc = leftOfAs.loc.start;
         
-        if (this.isContextual(93)) {
+        if (this.isContextual(89)) {
             const firstAs = this.parseIdentifier();
             
-            if (this.isContextual(93)) {
+            if (this.isContextual(89)) {
                 const secondAs = this.parseIdentifier();
                 
                 if (tokenIsKeywordOrIdentifier(this.state.type)) {
@@ -28403,7 +28384,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             if (isImport2) {
                 leftOfAs = this.parseIdentifier(true);
                 
-                if (!this.isContextual(93)) {
+                if (!this.isContextual(89)) {
                     this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
                 }
             } else {
@@ -28421,7 +28402,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         
         node[kindKey] = hasTypeSpecifier ? 'type' : 'value';
         
-        if (canParseAsKeyword && this.eatContextual(93)) {
+        if (canParseAsKeyword && this.eatContextual(89)) {
             node[rightOfAsKey] = isImport2 ? this.parseIdentifier() : this.parseModuleExportName();
         }
         
@@ -28685,13 +28666,13 @@ var PlaceholderErrors = ParseErrorEnum`placeholders`({
 
 var placeholders = (superClass) => class PlaceholdersParserMixin extends superClass {
     parsePlaceholder(expectedNode) {
-        if (this.match(133)) {
+        if (this.match(129)) {
             const node = this.startNode();
             this.next();
             this.assertNoSpace();
             node.name = super.parseIdentifier(true);
             this.assertNoSpace();
-            this.expect(133);
+            this.expect(129);
             return this.finishPlaceholder(node, expectedNode);
         }
     }
@@ -28709,7 +28690,7 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
     
     getTokenFromCode(code2) {
         if (code2 === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
-            this.finishOp(133, 2);
+            this.finishOp(129, 2);
         } else {
             super.getTokenFromCode(code2);
         }
@@ -28789,7 +28770,7 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
             return super.parseExpressionStatement(node, expr);
         }
         
-        if (this.match(14)) {
+        if (this.match(10)) {
             const stmt = node;
             
             stmt.label = this.finishPlaceholder(expr, 'Identifier');
@@ -28820,7 +28801,7 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
         const placeholder2 = this.parsePlaceholder('Identifier');
         
         if (placeholder2) {
-            if (this.match(81) || this.match(133) || this.match(5)) {
+            if (this.match(77) || this.match(129) || this.match(2)) {
                 node.id = placeholder2;
             } else if (optionalId || !isStatement5) {
                 node.id = null;
@@ -28846,7 +28827,7 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
         
         const node2 = node;
         
-        if (!this.isContextual(98) && !this.match(12)) {
+        if (!this.isContextual(94) && !this.match(8)) {
             node2.specifiers = [];
             node2.source = null;
             node2.declaration = this.finishPlaceholder(placeholder2, 'Declaration');
@@ -28864,11 +28845,11 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
     }
     
     isExportDefaultSpecifier() {
-        if (this.match(65)) {
+        if (this.match(61)) {
             const next = this.nextTokenStart();
             
             if (this.isUnparsedContextual(next, 'from')) {
-                if (this.input.startsWith(tokenLabelName(133), this.nextTokenStartSince(next + 4))) {
+                if (this.input.startsWith(tokenLabelName(129), this.nextTokenStartSince(next + 4))) {
                     return true;
                 }
             }
@@ -28904,7 +28885,7 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
         
         node.specifiers = [];
         
-        if (!this.isContextual(98) && !this.match(12)) {
+        if (!this.isContextual(94) && !this.match(8)) {
             node.source = this.finishPlaceholder(placeholder2, 'StringLiteral');
             this.semicolon();
             return this.finishNode(node, 'ImportDeclaration');
@@ -28915,14 +28896,14 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
         specifier.local = placeholder2;
         node.specifiers.push(this.finishNode(specifier, 'ImportDefaultSpecifier'));
         
-        if (this.eat(12)) {
+        if (this.eat(8)) {
             const hasStarImport = this.maybeParseStarImportSpecifier(node);
             
             if (!hasStarImport)
                 this.parseNamedImportSpecifiers(node);
         }
         
-        this.expectContextual(98);
+        this.expectContextual(94);
         node.source = this.parseImportSource();
         this.semicolon();
         return this.finishNode(node, 'ImportDeclaration');
@@ -28941,7 +28922,7 @@ var placeholders = (superClass) => class PlaceholdersParserMixin extends superCl
 
 var v8intrinsic = (superClass) => class V8IntrinsicMixin extends superClass {
     parseV8Intrinsic() {
-        if (this.match(54)) {
+        if (this.match(50)) {
             const v8IntrinsicStartLoc = this.state.startLoc;
             const node = this.startNode();
             this.next();
@@ -28951,7 +28932,7 @@ var v8intrinsic = (superClass) => class V8IntrinsicMixin extends superClass {
                 const identifier4 = this.createIdentifier(node, name);
                 this.castNodeTo(identifier4, 'V8IntrinsicIdentifier');
                 
-                if (this.match(10)) {
+                if (this.match(6)) {
                     return identifier4;
                 }
             }
@@ -29108,13 +29089,13 @@ var ExpressionParser = class extends LValParser {
         this.enterInitialScopes();
         this.nextToken();
         
-        if (this.match(140)) {
+        if (this.match(135)) {
             throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc);
         }
         
         const expr = this.parseExpression();
         
-        if (!this.match(140)) {
+        if (!this.match(135)) {
             throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, {
                 unexpected: this.input.codePointAt(this.state.start),
             });
@@ -29125,7 +29106,7 @@ var ExpressionParser = class extends LValParser {
         expr.errors = this.state.errors;
         
         if (this.optionFlags & 256) {
-            expr.tokens = this.tokens;
+            expr.tokens = createExportedTokens(this.tokens);
         }
         
         return expr;
@@ -29143,11 +29124,11 @@ var ExpressionParser = class extends LValParser {
         const startLoc = this.state.startLoc;
         const expr = this.parseMaybeAssign(refExpressionErrors);
         
-        if (this.match(12)) {
+        if (this.match(8)) {
             const node = this.startNodeAt(startLoc);
             
             node.expressions = [expr];
-            while (this.eat(12)) {
+            while (this.eat(8)) {
                 node.expressions.push(this.parseMaybeAssign(refExpressionErrors));
             }
             
@@ -29172,7 +29153,7 @@ var ExpressionParser = class extends LValParser {
     
     parseMaybeAssign(refExpressionErrors, afterLeftParse) {
         const startLoc = this.state.startLoc;
-        const isYield = this.isContextual(108);
+        const isYield = this.isContextual(104);
         
         if (isYield) {
             if (this.prodParam.hasYield) {
@@ -29198,7 +29179,7 @@ var ExpressionParser = class extends LValParser {
         
         const {type} = this.state;
         
-        if (type === 10 || tokenIsIdentifier(type)) {
+        if (type === 6 || tokenIsIdentifier(type)) {
             this.state.potentialArrowAt = this.state.start;
         }
         
@@ -29214,7 +29195,7 @@ var ExpressionParser = class extends LValParser {
             
             node.operator = operator;
             
-            if (this.match(29)) {
+            if (this.match(25)) {
                 this.toAssignable(left, true);
                 node.left = left;
                 const startIndex = startLoc.index;
@@ -29250,7 +29231,7 @@ var ExpressionParser = class extends LValParser {
         if (isYield) {
             const {type: type2} = this.state;
             
-            const startsExpr2 = this.hasPlugin('v8intrinsic') ? tokenCanStartExpression(type2) : tokenCanStartExpression(type2) && !this.match(54);
+            const startsExpr2 = this.hasPlugin('v8intrinsic') ? tokenCanStartExpression(type2) : tokenCanStartExpression(type2) && !this.match(50);
             
             if (startsExpr2 && !this.isAmbiguousPrefixOrIdentifier()) {
                 this.raiseOverwrite(Errors.YieldNotInGeneratorFunction, startLoc);
@@ -29274,12 +29255,12 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseConditional(expr, startLoc) {
-        if (this.eat(17)) {
+        if (this.eat(13)) {
             const node = this.startNodeAt(startLoc);
             
             node.test = expr;
             node.consequent = this.parseMaybeAssignAllowIn();
-            this.expect(14);
+            this.expect(10);
             node.alternate = this.parseMaybeAssign();
             return this.finishNode(node, 'ConditionalExpression');
         }
@@ -29288,7 +29269,7 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseMaybeUnaryOrPrivate(refExpressionErrors) {
-        return this.match(139) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
+        return this.match(134) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
     }
     
     parseExprOps(refExpressionErrors) {
@@ -29307,7 +29288,7 @@ var ExpressionParser = class extends LValParser {
         if (this.isPrivateName(left)) {
             const value = this.getPrivateNameSV(left);
             
-            if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
+            if (minPrec >= tokenOperatorPrecedence(54) || !this.prodParam.hasIn || !this.match(54)) {
                 this.raise(Errors.PrivateInExpectedIn, left, {
                     identifierName: value,
                 });
@@ -29318,11 +29299,11 @@ var ExpressionParser = class extends LValParser {
         
         const op = this.state.type;
         
-        if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {
+        if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(54))) {
             let prec = tokenOperatorPrecedence(op);
             
             if (prec > minPrec) {
-                if (op === 39) {
+                if (op === 35) {
                     this.expectPlugin('pipelineOperator');
                     
                     if (this.state.inFSharpPipelineDirectBody) {
@@ -29334,11 +29315,11 @@ var ExpressionParser = class extends LValParser {
                 
                 node.left = left;
                 node.operator = this.state.value;
-                const logical = op === 41 || op === 42;
-                const coalesce = op === 40;
+                const logical = op === 37 || op === 38;
+                const coalesce = op === 36;
                 
                 if (coalesce) {
-                    prec = tokenOperatorPrecedence(42);
+                    prec = tokenOperatorPrecedence(38);
                 }
                 
                 this.next();
@@ -29346,7 +29327,7 @@ var ExpressionParser = class extends LValParser {
                 const finishedNode = this.finishNode(node, logical || coalesce ? 'LogicalExpression' : 'BinaryExpression');
                 const nextOp = this.state.type;
                 
-                if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
+                if (coalesce && (nextOp === 37 || nextOp === 38) || logical && nextOp === 36) {
                     throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc);
                 }
                 
@@ -29359,7 +29340,7 @@ var ExpressionParser = class extends LValParser {
     
     parseExprOpRightExpr(op, prec) {
         switch(op) {
-        case 39:
+        case 35:
             switch(this.getPluginOption('pipelineOperator', 'proposal')) {
             case 'hack':
                 return this.withTopicBindingContext(() => {
@@ -29402,14 +29383,14 @@ var ExpressionParser = class extends LValParser {
     }
     
     checkExponentialAfterUnary(node) {
-        if (this.match(57)) {
+        if (this.match(53)) {
             this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);
         }
     }
     
     parseMaybeUnary(refExpressionErrors, sawUnary) {
         const startLoc = this.state.startLoc;
-        const isAwait = this.isContextual(96);
+        const isAwait = this.isContextual(92);
         
         if (isAwait && this.recordAwaitIfAllowed()) {
             this.next();
@@ -29421,18 +29402,18 @@ var ExpressionParser = class extends LValParser {
             return expr2;
         }
         
-        const update = this.match(34);
+        const update = this.match(30);
         const node = this.startNode();
         
         if (tokenIsPrefix(this.state.type)) {
             node.operator = this.state.value;
             node.prefix = true;
             
-            if (this.match(72)) {
+            if (this.match(68)) {
                 this.expectPlugin('throwExpressions');
             }
             
-            const isDelete = this.match(89);
+            const isDelete = this.match(85);
             this.next();
             node.argument = this.parseMaybeUnary(null, true);
             this.checkExpressionErrors(refExpressionErrors, true);
@@ -29461,7 +29442,7 @@ var ExpressionParser = class extends LValParser {
         if (isAwait) {
             const {type} = this.state;
             
-            const startsExpr2 = this.hasPlugin('v8intrinsic') ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
+            const startsExpr2 = this.hasPlugin('v8intrinsic') ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(50);
             
             if (startsExpr2 && !this.isAmbiguousPrefixOrIdentifier()) {
                 this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);
@@ -29531,7 +29512,7 @@ var ExpressionParser = class extends LValParser {
     parseSubscript(base, startLoc, noCalls, state) {
         const {type} = this.state;
         
-        if (!noCalls && type === 15) {
+        if (!noCalls && type === 11) {
             return this.parseBind(base, startLoc, noCalls, state);
         } else if (tokenIsTemplate(type)) {
             return this.parseTaggedTemplateExpression(base, startLoc, state);
@@ -29539,7 +29520,7 @@ var ExpressionParser = class extends LValParser {
         
         let optional = false;
         
-        if (type === 18) {
+        if (type === 14) {
             if (noCalls) {
                 this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);
                 
@@ -29553,12 +29534,12 @@ var ExpressionParser = class extends LValParser {
             this.next();
         }
         
-        if (!noCalls && this.match(10)) {
+        if (!noCalls && this.match(6)) {
             return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);
         } else {
             const computed = this.eat(0);
             
-            if (computed || optional || this.eat(16)) {
+            if (computed || optional || this.eat(12)) {
                 return this.parseMember(base, startLoc, state, computed, optional);
             } else {
                 return this.stopParseSubscript(base, state);
@@ -29579,8 +29560,8 @@ var ExpressionParser = class extends LValParser {
         
         if (computed) {
             node.property = this.parseExpression();
-            this.expect(3);
-        } else if (this.match(139)) {
+            this.expect(1);
+        } else if (this.match(134)) {
             if (base.type === 'Super') {
                 this.raise(Errors.SuperPrivateField, startLoc);
             }
@@ -29707,13 +29688,13 @@ var ExpressionParser = class extends LValParser {
         const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
         
         this.state.inFSharpPipelineDirectBody = false;
-        while (!this.eat(11)) {
+        while (!this.eat(7)) {
             if (first) {
                 first = false;
             } else {
-                this.expect(12);
+                this.expect(8);
                 
-                if (this.match(11)) {
+                if (this.match(7)) {
                     if (nodeForExtra) {
                         this.addTrailingCommaExtraToNode(nodeForExtra);
                     }
@@ -29724,7 +29705,7 @@ var ExpressionParser = class extends LValParser {
             }
             
             elts.push(this.parseExprListItem(
-                11,
+                7,
                 false,
                 refExpressionErrors,
                 allowPlaceholder,
@@ -29736,12 +29717,12 @@ var ExpressionParser = class extends LValParser {
     }
     
     shouldParseAsyncArrow() {
-        return this.match(19) && !this.canInsertSemicolon();
+        return this.match(15) && !this.canInsertSemicolon();
     }
     
     parseAsyncArrowFromCallExpression(node, call2) {
         this.resetPreviousNodeTrailingComments(call2);
-        this.expect(19);
+        this.expect(15);
         this.parseArrowExpression(node, call2.arguments, true, call2.extra?.trailingCommaLoc);
         
         if (call2.innerComments) {
@@ -29766,18 +29747,18 @@ var ExpressionParser = class extends LValParser {
         const {type} = this.state;
         
         switch(type) {
-        case 79:
+        case 75:
             return this.parseSuper();
         
-        case 83:
+        case 79:
             node = this.startNode();
             this.next();
             
-            if (this.match(16)) {
+            if (this.match(12)) {
                 return this.parseImportMetaPropertyOrPhaseCall(node);
             }
             
-            if (this.match(10)) {
+            if (this.match(6)) {
                 if (this.optionFlags & 512) {
                     return this.parseImportCall(node);
                 } else {
@@ -29788,69 +29769,69 @@ var ExpressionParser = class extends LValParser {
                 return this.finishNode(node, 'Import');
             }
         
-        case 78:
+        case 74:
             node = this.startNode();
             this.next();
             return this.finishNode(node, 'ThisExpression');
         
-        case 90: {
+        case 86: {
             return this.parseDo(this.startNode(), false);
         }
         
-        case 56:        
-        case 31: {
+        case 52:        
+        case 27: {
             this.readRegexp();
             return this.parseRegExpLiteral(this.state.value);
         }
         
-        case 135:
+        case 131:
             return this.parseNumericLiteral(this.state.value);
         
-        case 136:
+        case 132:
             return this.parseBigIntLiteral(this.state.value);
         
-        case 134:
+        case 130:
             return this.parseStringLiteral(this.state.value);
         
-        case 84:
+        case 80:
             return this.parseNullLiteral();
         
-        case 85:
+        case 81:
             return this.parseBooleanLiteral(true);
         
-        case 86:
+        case 82:
             return this.parseBooleanLiteral(false);
         
-        case 10: {
+        case 6: {
             const canBeArrow = this.state.potentialArrowAt === this.state.start;
             return this.parseParenAndDistinguishExpression(canBeArrow);
         }
         
         case 0: {
-            return this.parseArrayLike(3, refExpressionErrors);
+            return this.parseArrayLike(1, refExpressionErrors);
         }
         
-        case 5: {
-            return this.parseObjectLike(8, false, refExpressionErrors);
+        case 2: {
+            return this.parseObjectLike(4, false, refExpressionErrors);
         }
         
-        case 68:
+        case 64:
             return this.parseFunctionOrFunctionSent();
         
-        case 26:
+        case 22:
             decorators = this.parseDecorators();
         
-        case 80:
+        case 76:
             return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);
         
-        case 77:
+        case 73:
             return this.parseNewOrNewTarget();
         
-        case 25:        
-        case 24:
+        case 21:        
+        case 20:
             return this.parseTemplate(false);
         
-        case 15: {
+        case 11: {
             node = this.startNode();
             this.next();
             node.object = null;
@@ -29863,29 +29844,29 @@ var ExpressionParser = class extends LValParser {
             }
         }
         
-        case 139: {
+        case 134: {
             this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, {
                 identifierName: this.state.value,
             });
             return this.parsePrivateName();
         }
         
-        case 33: {
-            return this.parseTopicReferenceThenEqualsSign(54, '%');
+        case 29: {
+            return this.parseTopicReferenceThenEqualsSign(50, '%');
         }
         
-        case 32: {
-            return this.parseTopicReferenceThenEqualsSign(44, '^');
+        case 28: {
+            return this.parseTopicReferenceThenEqualsSign(40, '^');
         }
         
-        case 37:        
-        case 38: {
+        case 33:        
+        case 34: {
             return this.parseTopicReference('hack');
         }
         
-        case 44:        
-        case 54:        
-        case 27: {
+        case 40:        
+        case 50:        
+        case 23: {
             const pipeProposal = this.getPluginOption('pipelineOperator', 'proposal');
             
             if (pipeProposal) {
@@ -29895,7 +29876,7 @@ var ExpressionParser = class extends LValParser {
             throw this.unexpected();
         }
         
-        case 47: {
+        case 43: {
             const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
             
             if (isIdentifierStart2(lookaheadCh) || lookaheadCh === 62) {
@@ -29907,7 +29888,7 @@ var ExpressionParser = class extends LValParser {
         
         default:
             if (tokenIsIdentifier(type)) {
-                if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) {
+                if (this.isContextual(123) && this.lookaheadInLineCharCode() === 123) {
                     return this.parseModuleExpression();
                 }
                 
@@ -29918,7 +29899,7 @@ var ExpressionParser = class extends LValParser {
                 if (!containsEsc && id.name === 'async' && !this.canInsertSemicolon()) {
                     const {type: type2} = this.state;
                     
-                    if (type2 === 68) {
+                    if (type2 === 64) {
                         this.resetPreviousNodeTrailingComments(id);
                         this.next();
                         return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
@@ -29928,14 +29909,14 @@ var ExpressionParser = class extends LValParser {
                         } else {
                             return id;
                         }
-                    } else if (type2 === 90) {
+                    } else if (type2 === 86) {
                         this.resetPreviousNodeTrailingComments(id);
                         return this.parseDo(this.startNodeAtNode(id), true);
                     }
 
                 }
                 
-                if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {
+                if (canBeArrow && this.match(15) && !this.canInsertSemicolon()) {
                     this.next();
                     return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
                 }
@@ -30010,7 +29991,7 @@ var ExpressionParser = class extends LValParser {
             this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition());
         }
         
-        this.expect(19);
+        this.expect(15);
         return this.parseArrowExpression(node, params, true);
     }
     
@@ -30043,13 +30024,13 @@ var ExpressionParser = class extends LValParser {
         const node = this.startNode();
         this.next();
         
-        if (this.match(10) && !this.scope.allowDirectSuper) {
+        if (this.match(6) && !this.scope.allowDirectSuper) {
             this.raise(Errors.SuperNotAllowed, node);
         } else if (!this.scope.allowSuper) {
             this.raise(Errors.UnexpectedSuper, node);
         }
         
-        if (!this.match(10) && !this.match(0) && !this.match(16)) {
+        if (!this.match(6) && !this.match(0) && !this.match(12)) {
             this.raise(Errors.UnsupportedSuper, node);
         }
         
@@ -30070,11 +30051,11 @@ var ExpressionParser = class extends LValParser {
         const node = this.startNode();
         this.next();
         
-        if (this.prodParam.hasYield && this.match(16)) {
+        if (this.prodParam.hasYield && this.match(12)) {
             const meta = this.createIdentifier(this.startNodeAtNode(node), 'function');
             this.next();
             
-            if (this.match(103)) {
+            if (this.match(99)) {
                 this.expectPlugin('functionSent');
             } else if (!this.hasPlugin('functionSent')) {
                 this.unexpected();
@@ -30105,8 +30086,8 @@ var ExpressionParser = class extends LValParser {
     parseImportMetaPropertyOrPhaseCall(node) {
         this.next();
         
-        if (this.isContextual(105) || this.isContextual(97)) {
-            const isSource = this.isContextual(105);
+        if (this.isContextual(101) || this.isContextual(93)) {
+            const isSource = this.isContextual(101);
             this.expectPlugin(isSource ? 'sourcePhaseImports' : 'deferredImportEvaluation');
             this.next();
             node.phase = isSource ? 'source' : 'defer';
@@ -30114,7 +30095,7 @@ var ExpressionParser = class extends LValParser {
         } else {
             const id = this.createIdentifierAt(this.startNodeAtNode(node), 'import', this.state.lastTokStartLoc);
             
-            if (this.isContextual(101)) {
+            if (this.isContextual(97)) {
                 if (!this.inModule) {
                     this.raise(Errors.ImportMetaOutsideModule, id);
                 }
@@ -30202,19 +30183,19 @@ var ExpressionParser = class extends LValParser {
         let spreadStartLoc;
         let optionalCommaStartLoc;
         
-        while (!this.match(11)) {
+        while (!this.match(7)) {
             if (first) {
                 first = false;
             } else {
-                this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
+                this.expect(8, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
                 
-                if (this.match(11)) {
+                if (this.match(7)) {
                     optionalCommaStartLoc = this.state.startLoc;
                     break;
                 }
             }
             
-            if (this.match(21)) {
+            if (this.match(17)) {
                 const spreadNodeStartLoc = this.state.startLoc;
                 
                 spreadStartLoc = this.state.startLoc;
@@ -30228,7 +30209,7 @@ var ExpressionParser = class extends LValParser {
                 }
             } else {
                 exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(
-                    11,
+                    7,
                     refExpressionErrors,
                     this.parseParenItem,
                 ));
@@ -30236,7 +30217,7 @@ var ExpressionParser = class extends LValParser {
         }
         
         const innerEndLoc = this.state.lastTokEndLoc;
-        this.expect(11);
+        this.expect(7);
         this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
         this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
         let arrowNode = this.startNodeAt(startLoc);
@@ -30295,7 +30276,7 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseArrow(node) {
-        if (this.eat(19)) {
+        if (this.eat(15)) {
             return node;
         }
     }
@@ -30308,7 +30289,7 @@ var ExpressionParser = class extends LValParser {
         const node = this.startNode();
         this.next();
         
-        if (this.match(16)) {
+        if (this.match(12)) {
             const meta = this.createIdentifier(this.startNodeAtNode(node), 'new');
             this.next();
             const metaProp = this.parseMetaProperty(node, meta, 'target');
@@ -30326,8 +30307,8 @@ var ExpressionParser = class extends LValParser {
     parseNew(node) {
         this.parseNewCallee(node);
         
-        if (this.eat(10)) {
-            const args = this.parseExprList(11);
+        if (this.eat(6)) {
+            const args = this.parseExprList(7);
             this.toReferencedList(args);
             node.arguments = args;
         } else {
@@ -30338,7 +30319,7 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseNewCallee(node) {
-        const isImport2 = this.match(83);
+        const isImport2 = this.match(79);
         const callee = this.parseNoCallExpr();
         
         node.callee = callee;
@@ -30365,7 +30346,7 @@ var ExpressionParser = class extends LValParser {
             }
         }
         
-        const isTail = this.match(24);
+        const isTail = this.match(20);
         const endOffset = isTail ? -1 : -2;
         const elemEnd = end + endOffset;
         
@@ -30418,7 +30399,7 @@ var ExpressionParser = class extends LValParser {
             if (first) {
                 first = false;
             } else {
-                this.expect(12);
+                this.expect(8);
                 
                 if (this.match(close)) {
                     this.addTrailingCommaExtraToNode(node);
@@ -30454,18 +30435,18 @@ var ExpressionParser = class extends LValParser {
         return !prop.computed && prop.key.type === 'Identifier'
             && (this.isLiteralPropertyName()
             || this.match(0)
-            || this.match(55));
+            || this.match(51));
     }
     
     parsePropertyDefinition(refExpressionErrors) {
         let decorators = [];
         
-        if (this.match(26)) {
+        if (this.match(22)) {
             if (this.hasPlugin('decorators')) {
                 this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);
             }
             
-            while (this.match(26)) {
+            while (this.match(22)) {
                 decorators.push(this.parseDecorator());
             }
         }
@@ -30475,7 +30456,7 @@ var ExpressionParser = class extends LValParser {
         let isAccessor2 = false;
         let startLoc;
         
-        if (this.match(21)) {
+        if (this.match(17)) {
             if (decorators.length)
                 this.unexpected();
             
@@ -30493,7 +30474,7 @@ var ExpressionParser = class extends LValParser {
             startLoc = this.state.startLoc;
         }
         
-        let isGenerator = this.eat(55);
+        let isGenerator = this.eat(51);
         this.parsePropertyNamePrefixOperator(prop);
         const containsEsc = this.state.containsEsc;
         this.parsePropertyName(prop, refExpressionErrors);
@@ -30506,7 +30487,7 @@ var ExpressionParser = class extends LValParser {
             if (keyName === 'async' && !this.hasPrecedingLineBreak()) {
                 isAsync = true;
                 this.resetPreviousNodeTrailingComments(key);
-                isGenerator = this.eat(55);
+                isGenerator = this.eat(51);
                 this.parsePropertyName(prop);
             }
             
@@ -30515,7 +30496,7 @@ var ExpressionParser = class extends LValParser {
                 this.resetPreviousNodeTrailingComments(key);
                 prop.kind = keyName;
                 
-                if (this.match(55)) {
+                if (this.match(51)) {
                     isGenerator = true;
                     this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), {
                         kind: keyName,
@@ -30558,7 +30539,7 @@ var ExpressionParser = class extends LValParser {
             return finishedProp;
         }
         
-        if (isAsync || isGenerator || this.match(10)) {
+        if (isAsync || isGenerator || this.match(6)) {
             if (isPattern3)
                 this.unexpected();
             
@@ -30571,8 +30552,8 @@ var ExpressionParser = class extends LValParser {
     parseObjectProperty(prop, startLoc, isPattern3, refExpressionErrors) {
         prop.shorthand = false;
         
-        if (this.eat(14)) {
-            prop.value = isPattern3 ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(8, refExpressionErrors);
+        if (this.eat(10)) {
+            prop.value = isPattern3 ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(4, refExpressionErrors);
             return this.finishObjectProperty(prop);
         }
         
@@ -30581,7 +30562,7 @@ var ExpressionParser = class extends LValParser {
             
             if (isPattern3) {
                 prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));
-            } else if (this.match(29)) {
+            } else if (this.match(25)) {
                 const shorthandAssignLoc = this.state.startLoc;
                 
                 if (refExpressionErrors != null) {
@@ -30619,7 +30600,7 @@ var ExpressionParser = class extends LValParser {
         if (this.eat(0)) {
             prop.computed = true;
             prop.key = this.parseMaybeAssignAllowIn();
-            this.expect(3);
+            this.expect(1);
         } else {
             const {type, value} = this.state;
             
@@ -30629,19 +30610,19 @@ var ExpressionParser = class extends LValParser {
                 key = this.parseIdentifier(true);
             } else {
                 switch(type) {
-                case 135:
+                case 131:
                     key = this.parseNumericLiteral(value);
                     break;
                 
-                case 134:
+                case 130:
                     key = this.parseStringLiteral(value);
                     break;
                 
-                case 136:
+                case 132:
                     key = this.parseBigIntLiteral(value);
                     break;
                 
-                case 139: {
+                case 134: {
                     const privateKeyLoc = this.state.startLoc;
                     
                     if (refExpressionErrors != null) {
@@ -30663,7 +30644,7 @@ var ExpressionParser = class extends LValParser {
             
             prop.key = key;
             
-            if (type !== 139) {
+            if (type !== 134) {
                 prop.computed = false;
             }
         }
@@ -30702,7 +30683,7 @@ var ExpressionParser = class extends LValParser {
         this.scope.enter(514 | 4);
         let flags = functionFlags(isAsync, false);
         
-        if (!this.match(5) && this.prodParam.hasIn) {
+        if (!this.match(2) && this.prodParam.hasIn) {
             flags |= 8;
         }
         
@@ -30734,7 +30715,7 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseFunctionBody(node, allowExpression, isMethod3 = false) {
-        const isExpression4 = allowExpression && !this.match(5);
+        const isExpression4 = allowExpression && !this.match(2);
         this.expressionScope.enter(newExpressionScope());
         
         if (isExpression4) {
@@ -30799,7 +30780,7 @@ var ExpressionParser = class extends LValParser {
             if (first) {
                 first = false;
             } else {
-                this.expect(12);
+                this.expect(8);
                 
                 if (this.match(close)) {
                     if (nodeForExtra) {
@@ -30824,7 +30805,7 @@ var ExpressionParser = class extends LValParser {
     parseExprListItem(close, allowEmpty, refExpressionErrors, allowPlaceholder) {
         let elt;
         
-        if (this.match(12)) {
+        if (this.match(8)) {
             if (!allowEmpty) {
                 this.raise(Errors.UnexpectedToken, this.state.curPosition(), {
                     unexpected: ',',
@@ -30832,10 +30813,10 @@ var ExpressionParser = class extends LValParser {
             }
             
             elt = null;
-        } else if (this.match(21)) {
+        } else if (this.match(17)) {
             const spreadNodeStartLoc = this.state.startLoc;
             elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
-        } else if (this.match(17)) {
+        } else if (this.match(13)) {
             this.expectPlugin('partialApplication');
             
             if (!allowPlaceholder) {
@@ -30885,7 +30866,7 @@ var ExpressionParser = class extends LValParser {
         
         if (liberal) {
             if (tokenIsKeyword2) {
-                this.replaceToken(132);
+                this.replaceToken(128);
             }
         } else {
             this.checkReservedWord(name, startLoc, tokenIsKeyword2, false);
@@ -30959,7 +30940,7 @@ var ExpressionParser = class extends LValParser {
         const node = this.startNodeAt(startLoc);
         this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);
         
-        if (this.eat(55)) {
+        if (this.eat(51)) {
             this.raise(Errors.ObsoleteAwaitStar, node);
         }
         
@@ -30984,15 +30965,15 @@ var ExpressionParser = class extends LValParser {
         
         const {type} = this.state;
         
-        return type === 53
-            || type === 10
+        return type === 49
+            || type === 6
             || type === 0
             || tokenIsTemplate(type)
-            || type === 102
+            || type === 98
             && !this.state.containsEsc
-            || type === 138
-            || type === 56
-            || this.hasPlugin('v8intrinsic') && type === 54;
+            || type === 133
+            || type === 52
+            || this.hasPlugin('v8intrinsic') && type === 50;
     }
     
     parseYield(startLoc) {
@@ -31002,16 +30983,16 @@ var ExpressionParser = class extends LValParser {
         let argument = null;
         
         if (!this.hasPrecedingLineBreak()) {
-            delegating = this.eat(55);
+            delegating = this.eat(51);
             switch(this.state.type) {
-            case 13:            
-            case 140:            
-            case 8:            
-            case 11:            
-            case 3:            
             case 9:            
-            case 14:            
-            case 12:
+            case 135:            
+            case 4:            
+            case 7:            
+            case 1:            
+            case 5:            
+            case 10:            
+            case 8:
                 if (!delegating)
                     break;
             
@@ -31030,17 +31011,17 @@ var ExpressionParser = class extends LValParser {
         node.source = this.parseMaybeAssignAllowIn();
         node.options = null;
         
-        if (this.eat(12)) {
-            if (!this.match(11)) {
+        if (this.eat(8)) {
+            if (!this.match(7)) {
                 node.options = this.parseMaybeAssignAllowIn();
                 
-                if (this.eat(12)) {
+                if (this.eat(8)) {
                     this.addTrailingCommaExtraToNode(node.options);
                     
-                    if (!this.match(11)) {
+                    if (!this.match(7)) {
                         do {
                             this.parseMaybeAssignAllowIn();
-                        } while (this.eat(12) && !this.match(11))
+                        } while (this.eat(8) && !this.match(7))
                         this.raise(Errors.ImportCallArity, node);
                     }
                 }
@@ -31049,7 +31030,7 @@ var ExpressionParser = class extends LValParser {
             }
         }
         
-        this.expect(11);
+        this.expect(7);
         return this.finishNode(node, 'ImportExpression');
     }
     
@@ -31140,8 +31121,8 @@ var ExpressionParser = class extends LValParser {
         const node = this.startNode();
         this.next();
         
-        if (!this.match(5)) {
-            this.unexpected(null, 5);
+        if (!this.match(2)) {
+            this.unexpected(null, 2);
         }
         
         const program3 = this.startNodeAt(this.state.endLoc);
@@ -31149,7 +31130,7 @@ var ExpressionParser = class extends LValParser {
         const revertScopes = this.initializeScopes(true);
         this.enterInitialScopes();
         try {
-            node.body = this.parseProgram(program3, 8, 'module');
+            node.body = this.parseProgram(program3, 4, 'module');
         } finally {
             revertScopes();
         }
@@ -31171,10 +31152,10 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, afterLeftParse) {
-        if (refExpressionErrors != null && this.match(88)) {
+        if (refExpressionErrors != null && this.match(84)) {
             const nextCode = this.lookaheadCharCode();
             
-            if (nextCode === 44 || nextCode === (close === 3 ? 93 : close === 8 ? 125 : 41) || nextCode === 61) {
+            if (nextCode === 44 || nextCode === (close === 1 ? 93 : close === 4 ? 125 : 41) || nextCode === 61) {
                 return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(refExpressionErrors));
             }
         }
@@ -31196,7 +31177,7 @@ var switchLabel = {
 var loneSurrogate = /[\uD800-\uDFFF]/u;
 var keywordRelationalOperator = /in(?:stanceof)?/y;
 
-function babel7CompatTokens(tokens) {
+function createExportedTokens(tokens) {
     for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
         const {type} = token;
@@ -31211,11 +31192,11 @@ function babel7CompatTokens(tokens) {
 
 var StatementParser = class extends ExpressionParser {
     parseTopLevel(file2, program3) {
-        file2.program = this.parseProgram(program3, 140, this.options.sourceType === 'module' ? 'module' : 'script');
+        file2.program = this.parseProgram(program3, 135, this.options.sourceType === 'module' ? 'module' : 'script');
         file2.comments = this.comments;
         
         if (this.optionFlags & 256) {
-            file2.tokens = babel7CompatTokens(this.tokens);
+            file2.tokens = createExportedTokens(this.tokens);
         }
         
         return this.finishNode(file2, 'File');
@@ -31240,7 +31221,7 @@ var StatementParser = class extends ExpressionParser {
         
         let finishedProgram;
         
-        if (end === 140) {
+        if (end === 135) {
             finishedProgram = this.finishNode(program3, 'Program');
         } else {
             finishedProgram = this.finishNodeAt(program3, 'Program', createPositionWithColumnOffset(this.state.startLoc, -1));
@@ -31265,7 +31246,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseInterpreterDirective() {
-        if (!this.match(28)) {
+        if (!this.match(24)) {
             return null;
         }
         
@@ -31277,7 +31258,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     isLet() {
-        if (!this.isContextual(100)) {
+        if (!this.isContextual(96)) {
             return false;
         }
         
@@ -31285,7 +31266,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     isUsing() {
-        if (!this.isContextual(107)) {
+        if (!this.isContextual(103)) {
             return false;
         }
         
@@ -31293,7 +31274,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     isForUsing() {
-        if (!this.isContextual(107)) {
+        if (!this.isContextual(103)) {
             return false;
         }
         
@@ -31323,7 +31304,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     isAwaitUsing() {
-        if (!this.isContextual(96)) {
+        if (!this.isContextual(92)) {
             return false;
         }
         
@@ -31412,7 +31393,7 @@ var StatementParser = class extends ExpressionParser {
     parseStatementLike(flags) {
         let decorators = null;
         
-        if (this.match(26)) {
+        if (this.match(22)) {
             decorators = this.parseDecorators(true);
         }
         
@@ -31427,22 +31408,22 @@ var StatementParser = class extends ExpressionParser {
         const topLevel = flags & 1;
         
         switch(startType) {
-        case 60:
+        case 56:
             return this.parseBreakContinueStatement(node, true);
         
-        case 63:
+        case 59:
             return this.parseBreakContinueStatement(node, false);
         
-        case 64:
+        case 60:
             return this.parseDebuggerStatement(node);
         
-        case 90:
+        case 86:
             return this.parseDoWhileStatement(node);
         
-        case 91:
+        case 87:
             return this.parseForStatement(node);
         
-        case 68:
+        case 64:
             if (this.lookaheadCharCode() === 46)
                 break;
             
@@ -31452,28 +31433,28 @@ var StatementParser = class extends ExpressionParser {
             
             return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
         
-        case 80:
+        case 76:
             if (!allowDeclaration)
                 this.unexpected();
             
             return this.parseClass(this.maybeTakeDecorators(decorators, node), true);
         
-        case 69:
+        case 65:
             return this.parseIfStatement(node);
         
-        case 70:
+        case 66:
             return this.parseReturnStatement(node);
         
-        case 71:
+        case 67:
             return this.parseSwitchStatement(node);
         
-        case 72:
+        case 68:
             return this.parseThrowStatement(node);
         
-        case 73:
+        case 69:
             return this.parseTryStatement(node);
         
-        case 96:
+        case 92:
             if (this.isAwaitUsing()) {
                 if (!this.allowsUsing()) {
                     this.raise(Errors.UnexpectedUsingDeclaration, node);
@@ -31489,7 +31470,7 @@ var StatementParser = class extends ExpressionParser {
             
             break;
         
-        case 107:
+        case 103:
             if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) {
                 break;
             }
@@ -31502,7 +31483,7 @@ var StatementParser = class extends ExpressionParser {
             
             return this.parseVarStatement(node, 'using');
         
-        case 100: {
+        case 96: {
             if (this.state.containsEsc) {
                 break;
             }
@@ -31520,30 +31501,30 @@ var StatementParser = class extends ExpressionParser {
             }
         }
         
-        case 75: {
+        case 71: {
             if (!allowDeclaration) {
                 this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
             }
         }
         
-        case 74: {
+        case 70: {
             const kind = this.state.value;
             return this.parseVarStatement(node, kind);
         }
         
-        case 92:
+        case 88:
             return this.parseWhileStatement(node);
         
-        case 76:
+        case 72:
             return this.parseWithStatement(node);
         
-        case 5:
+        case 2:
             return this.parseBlock();
         
-        case 13:
+        case 9:
             return this.parseEmptyStatement(node);
         
-        case 83: {
+        case 79: {
             const nextTokenCharCode = this.lookaheadCharCode();
             
             if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
@@ -31551,7 +31532,7 @@ var StatementParser = class extends ExpressionParser {
             }
         }
         
-        case 82: {
+        case 78: {
             if (!(this.optionFlags & 8) && !topLevel) {
                 this.raise(Errors.UnexpectedImportExport, this.state.startLoc);
             }
@@ -31559,7 +31540,7 @@ var StatementParser = class extends ExpressionParser {
             this.next();
             let result;
             
-            if (startType === 83) {
+            if (startType === 79) {
                 result = this.parseImport(node);
             } else {
                 result = this.parseExport(node, decorators);
@@ -31584,7 +31565,7 @@ var StatementParser = class extends ExpressionParser {
         const maybeName = this.state.value;
         const expr = this.parseExpression();
         
-        if (tokenIsIdentifier(startType) && expr.type === 'Identifier' && this.eat(14)) {
+        if (tokenIsIdentifier(startType) && expr.type === 'Identifier' && this.eat(10)) {
             return this.parseLabeledStatement(node, maybeName, expr, flags);
         } else {
             return this.parseExpressionStatement(node, expr, decorators);
@@ -31616,7 +31597,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     canHaveLeadingDecorator() {
-        return this.match(80);
+        return this.match(76);
     }
     
     parseDecorators(allowExport) {
@@ -31624,8 +31605,8 @@ var StatementParser = class extends ExpressionParser {
         
         do {
             decorators.push(this.parseDecorator());
-        } while (this.match(26))
-        if (this.match(82)) {
+        } while (this.match(22))
+        if (this.match(78)) {
             if (!allowExport) {
                 this.unexpected();
             }
@@ -31645,11 +31626,11 @@ var StatementParser = class extends ExpressionParser {
             const startLoc = this.state.startLoc;
             let expr;
             
-            if (this.match(10)) {
+            if (this.match(6)) {
                 const startLoc2 = this.state.startLoc;
                 this.next();
                 expr = this.parseExpression();
-                this.expect(11);
+                this.expect(7);
                 expr = this.wrapParenthesis(startLoc2, expr);
                 const paramsStartLoc = this.state.startLoc;
                 
@@ -31660,12 +31641,12 @@ var StatementParser = class extends ExpressionParser {
                 }
             } else {
                 expr = this.parseIdentifier(false);
-                while (this.eat(16)) {
+                while (this.eat(12)) {
                     const node2 = this.startNodeAt(startLoc);
                     
                     node2.object = expr;
                     
-                    if (this.match(139)) {
+                    if (this.match(134)) {
                         this.classScope.usePrivateName(this.state.value, this.state.startLoc);
                         node2.property = this.parsePrivateName();
                     } else {
@@ -31686,7 +31667,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseMaybeDecoratorArguments(expr, startLoc) {
-        if (this.eat(10)) {
+        if (this.eat(6)) {
             const node = this.startNodeAt(startLoc);
             
             node.callee = expr;
@@ -31744,9 +31725,9 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseHeaderExpression() {
-        this.expect(10);
+        this.expect(6);
         const val = this.parseExpression();
-        this.expect(11);
+        this.expect(7);
         return val;
     }
     
@@ -31755,9 +31736,9 @@ var StatementParser = class extends ExpressionParser {
         this.state.labels.push(loopLabel);
         node.body = this.parseStatement();
         this.state.labels.pop();
-        this.expect(92);
+        this.expect(88);
         node.test = this.parseHeaderExpression();
-        this.eat(13);
+        this.eat(9);
         return this.finishNode(node, 'DoWhileStatement');
     }
     
@@ -31766,15 +31747,15 @@ var StatementParser = class extends ExpressionParser {
         this.state.labels.push(loopLabel);
         let awaitAt = null;
         
-        if (this.isContextual(96) && this.recordAwaitIfAllowed()) {
+        if (this.isContextual(92) && this.recordAwaitIfAllowed()) {
             awaitAt = this.state.startLoc;
             this.next();
         }
         
         this.scope.enter(0);
-        this.expect(10);
+        this.expect(6);
         
-        if (this.match(13)) {
+        if (this.match(9)) {
             if (awaitAt !== null) {
                 this.unexpected(awaitAt);
             }
@@ -31782,14 +31763,14 @@ var StatementParser = class extends ExpressionParser {
             return this.parseFor(node, null);
         }
         
-        const startsWithLet = this.isContextual(100);
+        const startsWithLet = this.isContextual(96);
         
         {
             const startsWithAwaitUsing = this.isAwaitUsing();
             const starsWithUsingDeclaration = startsWithAwaitUsing || this.isForUsing();
             const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
             
-            if (this.match(74) || this.match(75) || isLetOrUsing) {
+            if (this.match(70) || this.match(71) || isLetOrUsing) {
                 const initNode = this.startNode();
                 let kind;
                 
@@ -31808,13 +31789,13 @@ var StatementParser = class extends ExpressionParser {
                 this.next();
                 this.parseVar(initNode, true, kind);
                 const init2 = this.finishNode(initNode, 'VariableDeclaration');
-                const isForIn = this.match(58);
+                const isForIn = this.match(54);
                 
                 if (isForIn && starsWithUsingDeclaration) {
                     this.raise(Errors.ForInUsing, init2);
                 }
                 
-                if ((isForIn || this.isContextual(102)) && init2.declarations.length === 1) {
+                if ((isForIn || this.isContextual(98)) && init2.declarations.length === 1) {
                     return this.parseForIn(node, init2, awaitAt);
                 }
                 
@@ -31825,10 +31806,10 @@ var StatementParser = class extends ExpressionParser {
                 return this.parseFor(node, init2);
             }
         }
-        const startsWithAsync = this.isContextual(95);
+        const startsWithAsync = this.isContextual(91);
         const refExpressionErrors = new ExpressionErrors();
         const init = this.parseExpression(true, refExpressionErrors);
-        const isForOf = this.isContextual(102);
+        const isForOf = this.isContextual(98);
         
         if (isForOf) {
             if (startsWithLet) {
@@ -31840,7 +31821,7 @@ var StatementParser = class extends ExpressionParser {
             }
         }
         
-        if (isForOf || this.match(58)) {
+        if (isForOf || this.match(54)) {
             this.checkDestructuringPrivate(refExpressionErrors);
             this.toAssignable(init, true);
             const type = isForOf ? 'ForOfStatement' : 'ForInStatement';
@@ -31869,7 +31850,7 @@ var StatementParser = class extends ExpressionParser {
         this.next();
         node.test = this.parseHeaderExpression();
         node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
-        node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
+        node.alternate = this.eat(62) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
         return this.finishNode(node, 'IfStatement');
     }
     
@@ -31894,14 +31875,14 @@ var StatementParser = class extends ExpressionParser {
         this.next();
         node.discriminant = this.parseHeaderExpression();
         const cases = node.cases = [];
-        this.expect(5);
+        this.expect(2);
         this.state.labels.push(switchLabel);
         this.scope.enter(256);
         let cur;
         
-        for (let sawDefault; !this.match(8);) {
-            if (this.match(61) || this.match(65)) {
-                const isCase = this.match(61);
+        for (let sawDefault; !this.match(4);) {
+            if (this.match(57) || this.match(61)) {
+                const isCase = this.match(57);
                 
                 if (cur)
                     this.finishNode(cur, 'SwitchCase');
@@ -31921,7 +31902,7 @@ var StatementParser = class extends ExpressionParser {
                     cur.test = null;
                 }
                 
-                this.expect(14);
+                this.expect(10);
             } else {
                 if (cur) {
                     cur.consequent.push(this.parseStatementListItem());
@@ -31967,14 +31948,14 @@ var StatementParser = class extends ExpressionParser {
         node.block = this.parseBlock();
         node.handler = null;
         
-        if (this.match(62)) {
+        if (this.match(58)) {
             const clause = this.startNode();
             this.next();
             
-            if (this.match(10)) {
-                this.expect(10);
+            if (this.match(6)) {
+                this.expect(6);
                 clause.param = this.parseCatchClauseParam();
-                this.expect(11);
+                this.expect(7);
             } else {
                 clause.param = null;
                 this.scope.enter(0);
@@ -31985,7 +31966,7 @@ var StatementParser = class extends ExpressionParser {
             node.handler = this.finishNode(clause, 'CatchClause');
         }
         
-        node.finalizer = this.eat(67) ? this.parseBlock() : null;
+        node.finalizer = this.eat(63) ? this.parseBlock() : null;
         
         if (!node.handler && !node.finalizer) {
             this.raise(Errors.NoCatchOrFinally, node);
@@ -32035,7 +32016,7 @@ var StatementParser = class extends ExpressionParser {
             }
         }
         
-        const kind = tokenIsLoop(this.state.type) ? 1 : this.match(71) ? 2 : null;
+        const kind = tokenIsLoop(this.state.type) ? 1 : this.match(67) ? 2 : null;
         
         for (let i = this.state.labels.length - 1; i >= 0; i--) {
             const label = this.state.labels[i];
@@ -32072,13 +32053,13 @@ var StatementParser = class extends ExpressionParser {
             this.state.strictErrors.clear();
         }
         
-        this.expect(5);
+        this.expect(2);
         
         if (createNewLexicalScope) {
             this.scope.enter(0);
         }
         
-        this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);
+        this.parseBlockBody(node, allowDirectives, false, 4, afterBlockParse);
         
         if (createNewLexicalScope) {
             this.scope.exit();
@@ -32137,10 +32118,10 @@ var StatementParser = class extends ExpressionParser {
     parseFor(node, init) {
         node.init = init;
         this.semicolon(false);
-        node.test = this.match(13) ? null : this.parseExpression();
+        node.test = this.match(9) ? null : this.parseExpression();
         this.semicolon(false);
-        node.update = this.match(11) ? null : this.parseExpression();
-        this.expect(11);
+        node.update = this.match(7) ? null : this.parseExpression();
+        this.expect(7);
         node.body = this.parseStatement();
         this.scope.exit();
         this.state.labels.pop();
@@ -32148,7 +32129,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseForIn(node, init, awaitAt) {
-        const isForIn = this.match(58);
+        const isForIn = this.match(54);
         this.next();
         
         if (isForIn) {
@@ -32174,7 +32155,7 @@ var StatementParser = class extends ExpressionParser {
         
         node.left = init;
         node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
-        this.expect(11);
+        this.expect(7);
         node.body = this.parseStatement();
         this.scope.exit();
         this.state.labels.pop();
@@ -32188,14 +32169,14 @@ var StatementParser = class extends ExpressionParser {
         for (;;) {
             const decl = this.startNode();
             this.parseVarId(decl, kind);
-            decl.init = !this.eat(29) ? null : isFor3 ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
+            decl.init = !this.eat(25) ? null : isFor3 ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
             
             if (decl.init === null && !allowMissingInitializer) {
-                if (decl.id.type !== 'Identifier' && !(isFor3 && (this.match(58) || this.isContextual(102)))) {
+                if (decl.id.type !== 'Identifier' && !(isFor3 && (this.match(54) || this.isContextual(98)))) {
                     this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {
                         kind: 'destructuring',
                     });
-                } else if ((kind === 'const' || kind === 'using' || kind === 'await using') && !(this.match(58) || this.isContextual(102))) {
+                } else if ((kind === 'const' || kind === 'using' || kind === 'await using') && !(this.match(54) || this.isContextual(98))) {
                     this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {
                         kind,
                     });
@@ -32204,7 +32185,7 @@ var StatementParser = class extends ExpressionParser {
             
             declarations.push(this.finishNode(decl, 'VariableDeclarator'));
             
-            if (!this.eat(12))
+            if (!this.eat(8))
                 break;
         }
         
@@ -32242,7 +32223,7 @@ var StatementParser = class extends ExpressionParser {
         
         this.initFunction(node, isAsync);
         
-        if (this.match(55)) {
+        if (this.match(51)) {
             if (hangingDeclaration) {
                 this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc);
             }
@@ -32283,9 +32264,9 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseFunctionParams(node, isConstructor) {
-        this.expect(10);
+        this.expect(6);
         this.expressionScope.enter(newParameterDeclarationScope());
-        node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));
+        node.params = this.parseBindingList(7, 41, 2 | (isConstructor ? 4 : 0));
         this.expressionScope.exit();
     }
     
@@ -32308,11 +32289,11 @@ var StatementParser = class extends ExpressionParser {
     }
     
     isClassProperty() {
-        return this.match(29) || this.match(13) || this.match(8);
+        return this.match(25) || this.match(9) || this.match(4);
     }
     
     isClassMethod() {
-        return this.match(10);
+        return this.match(6);
     }
     
     nameIsConstructor(key) {
@@ -32335,9 +32316,9 @@ var StatementParser = class extends ExpressionParser {
         const classBody2 = this.startNode();
         
         classBody2.body = [];
-        this.expect(5);
-        while (!this.match(8)) {
-            if (this.eat(13)) {
+        this.expect(2);
+        while (!this.match(4)) {
+            if (this.eat(9)) {
                 if (decorators.length > 0) {
                     throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);
                 }
@@ -32345,7 +32326,7 @@ var StatementParser = class extends ExpressionParser {
                 continue;
             }
             
-            if (this.match(26)) {
+            if (this.match(22)) {
                 decorators.push(this.parseDecorator());
                 continue;
             }
@@ -32403,14 +32384,14 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseClassMember(classBody2, member, state) {
-        const isStatic2 = this.isContextual(106);
+        const isStatic2 = this.isContextual(102);
         
         if (isStatic2) {
             if (this.parseClassMemberFromModifier(classBody2, member)) {
                 return;
             }
             
-            if (this.eat(5)) {
+            if (this.eat(2)) {
                 this.parseClassStaticBlock(classBody2, member);
                 return;
             }
@@ -32431,9 +32412,9 @@ var StatementParser = class extends ExpressionParser {
         member.static = isStatic2;
         this.parsePropertyNamePrefixOperator(member);
         
-        if (this.eat(55)) {
+        if (this.eat(51)) {
             method.kind = 'method';
-            const isPrivateName3 = this.match(139);
+            const isPrivateName3 = this.match(134);
             this.parseClassElementName(method);
             this.parsePostMemberNameModifiers(method);
             
@@ -32493,14 +32474,14 @@ var StatementParser = class extends ExpressionParser {
             }
         } else if (maybeContextualKw === 'async' && !this.isLineTerminator()) {
             this.resetPreviousNodeTrailingComments(key);
-            const isGenerator = this.eat(55);
+            const isGenerator = this.eat(51);
             
             if (publicMember.optional) {
                 this.unexpected(maybeQuestionTokenStartLoc);
             }
             
             method.kind = 'method';
-            const isPrivate3 = this.match(139);
+            const isPrivate3 = this.match(134);
             this.parseClassElementName(method);
             this.parsePostMemberNameModifiers(publicMember);
             
@@ -32513,10 +32494,10 @@ var StatementParser = class extends ExpressionParser {
                 
                 this.pushClassMethod(classBody2, publicMethod, isGenerator, true, false, false);
             }
-        } else if ((maybeContextualKw === 'get' || maybeContextualKw === 'set') && !(this.match(55) && this.isLineTerminator())) {
+        } else if ((maybeContextualKw === 'get' || maybeContextualKw === 'set') && !(this.match(51) && this.isLineTerminator())) {
             this.resetPreviousNodeTrailingComments(key);
             method.kind = maybeContextualKw;
-            const isPrivate3 = this.match(139);
+            const isPrivate3 = this.match(134);
             this.parseClassElementName(publicMethod);
             
             if (isPrivate3) {
@@ -32533,7 +32514,7 @@ var StatementParser = class extends ExpressionParser {
         } else if (maybeContextualKw === 'accessor' && !this.isLineTerminator()) {
             this.expectPlugin('decoratorAutoAccessors');
             this.resetPreviousNodeTrailingComments(key);
-            const isPrivate3 = this.match(139);
+            const isPrivate3 = this.match(134);
             this.parseClassElementName(publicProp);
             this.pushClassAccessorProperty(classBody2, accessorProp, isPrivate3);
         } else if (this.isLineTerminator()) {
@@ -32554,11 +32535,11 @@ var StatementParser = class extends ExpressionParser {
     parseClassElementName(member) {
         const {type, value} = this.state;
         
-        if ((type === 132 || type === 134) && member.static && value === 'prototype') {
+        if ((type === 128 || type === 130) && member.static && value === 'prototype') {
             this.raise(Errors.StaticPrototype, this.state.startLoc);
         }
         
-        if (type === 139) {
+        if (type === 134) {
             if (value === 'constructor') {
                 this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);
             }
@@ -32580,7 +32561,7 @@ var StatementParser = class extends ExpressionParser {
         this.state.labels = [];
         this.prodParam.enter(0);
         const body = member.body = [];
-        this.parseBlockOrModuleBlockBody(body, void 0, false, 8);
+        this.parseBlockOrModuleBlockBody(body, void 0, false, 4);
         this.prodParam.exit();
         this.scope.exit();
         this.state.labels = oldLabels;
@@ -32665,7 +32646,7 @@ var StatementParser = class extends ExpressionParser {
         this.scope.enter(576 | 16);
         this.expressionScope.enter(newExpressionScope());
         this.prodParam.enter(0);
-        node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
+        node.value = this.eat(25) ? this.parseMaybeAssignAllowIn() : null;
         this.expressionScope.exit();
         this.prodParam.exit();
         this.scope.exit();
@@ -32688,16 +32669,16 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseClassSuper(node) {
-        node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
+        node.superClass = this.eat(77) ? this.parseExprSubscripts() : null;
     }
     
     parseExport(node, decorators) {
         const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
         const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
-        const parseAfterDefault = !hasDefault || this.eat(12);
+        const parseAfterDefault = !hasDefault || this.eat(8);
         const hasStar = parseAfterDefault && this.eatExportStar(node);
         const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
-        const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));
+        const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(8));
         const isFromRequired = hasDefault || hasStar;
         
         if (hasStar && !hasNamespace) {
@@ -32716,11 +32697,11 @@ var StatementParser = class extends ExpressionParser {
         const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
         
         if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
-            this.unexpected(null, 5);
+            this.unexpected(null, 2);
         }
         
         if (hasNamespace && parseAfterNamespace) {
-            this.unexpected(null, 98);
+            this.unexpected(null, 94);
         }
         
         let hasDeclaration;
@@ -32751,7 +32732,7 @@ var StatementParser = class extends ExpressionParser {
             return this.finishNode(node2, 'ExportNamedDeclaration');
         }
         
-        if (this.eat(65)) {
+        if (this.eat(61)) {
             const node2 = node;
             const decl = this.parseExportDefaultExpression();
             
@@ -32768,11 +32749,11 @@ var StatementParser = class extends ExpressionParser {
             return this.finishNode(node2, 'ExportDefaultDeclaration');
         }
         
-        throw this.unexpected(null, 5);
+        throw this.unexpected(null, 2);
     }
     
     eatExportStar() {
-        return this.eat(55);
+        return this.eat(51);
     }
     
     maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
@@ -32792,7 +32773,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     maybeParseExportNamespaceSpecifier(node) {
-        if (this.isContextual(93)) {
+        if (this.isContextual(89)) {
             node.specifiers ?? (node.specifiers = []);
             const specifier = this.startNodeAt(this.state.lastTokStartLoc);
             this.next();
@@ -32805,7 +32786,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     maybeParseExportNamedSpecifiers(node) {
-        if (this.match(5)) {
+        if (this.match(2)) {
             const node2 = node;
             
             if (!node2.specifiers)
@@ -32835,7 +32816,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     isAsyncFunction() {
-        if (!this.isContextual(95))
+        if (!this.isContextual(91))
             return false;
         
         const next = this.nextTokenInLineStart();
@@ -32846,7 +32827,7 @@ var StatementParser = class extends ExpressionParser {
     parseExportDefaultExpression() {
         const expr = this.startNode();
         
-        if (this.match(68)) {
+        if (this.match(64)) {
             this.next();
             return this.parseFunction(expr, 1 | 4);
         } else if (this.isAsyncFunction()) {
@@ -32855,15 +32836,15 @@ var StatementParser = class extends ExpressionParser {
             return this.parseFunction(expr, 1 | 4 | 8);
         }
         
-        if (this.match(80)) {
+        if (this.match(76)) {
             return this.parseClass(expr, true, true);
         }
         
-        if (this.match(26)) {
+        if (this.match(22)) {
             return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
         }
         
-        if (this.match(75) || this.match(74) || this.isLet() || this.isUsing() || this.isAwaitUsing()) {
+        if (this.match(71) || this.match(70) || this.isLet() || this.isUsing() || this.isAwaitUsing()) {
             throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);
         }
         
@@ -32873,7 +32854,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseExportDeclaration() {
-        if (this.match(80)) {
+        if (this.match(76)) {
             const node2 = this.parseClass(this.startNode(), true, false);
             return node2;
         }
@@ -32885,11 +32866,11 @@ var StatementParser = class extends ExpressionParser {
         const {type} = this.state;
         
         if (tokenIsIdentifier(type)) {
-            if (type === 95 && !this.state.containsEsc || type === 100) {
+            if (type === 91 && !this.state.containsEsc || type === 96) {
                 return false;
             }
             
-            if ((type === 130 || type === 129) && !this.state.containsEsc) {
+            if ((type === 126 || type === 125) && !this.state.containsEsc) {
                 const next2 = this.nextTokenStart();
                 const nextChar = this.input.charCodeAt(next2);
                 
@@ -32898,7 +32879,7 @@ var StatementParser = class extends ExpressionParser {
                     return false;
                 }
             }
-        } else if (!this.match(65)) {
+        } else if (!this.match(61)) {
             return false;
         }
         
@@ -32909,7 +32890,7 @@ var StatementParser = class extends ExpressionParser {
             return true;
         }
         
-        if (this.match(65) && hasFrom) {
+        if (this.match(61) && hasFrom) {
             const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
             return nextAfterFrom === 34 || nextAfterFrom === 39;
         }
@@ -32918,7 +32899,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseExportFrom(node, expect) {
-        if (this.eatContextual(98)) {
+        if (this.eatContextual(94)) {
             node.source = this.parseImportSource();
             this.checkExport(node);
             this.maybeParseImportAttributes(node);
@@ -32932,7 +32913,7 @@ var StatementParser = class extends ExpressionParser {
     shouldParseExportDeclaration() {
         const {type} = this.state;
         
-        if (type === 26) {
+        if (type === 22) {
             this.expectOnePlugin(['decorators', 'decorators-legacy']);
             
             if (this.hasPlugin('decorators')) {
@@ -32950,10 +32931,10 @@ var StatementParser = class extends ExpressionParser {
             return true;
         }
         
-        return type === 74
-            || type === 75
-            || type === 68
-            || type === 80
+        return type === 70
+            || type === 71
+            || type === 64
+            || type === 76
             || this.isLet()
             || this.isAsyncFunction();
     }
@@ -33054,19 +33035,19 @@ var StatementParser = class extends ExpressionParser {
     parseExportSpecifiers(isInTypeExport) {
         const nodes2 = [];
         let first = true;
-        this.expect(5);
-        while (!this.eat(8)) {
+        this.expect(2);
+        while (!this.eat(4)) {
             if (first) {
                 first = false;
             } else {
-                this.expect(12);
+                this.expect(8);
                 
-                if (this.eat(8))
+                if (this.eat(4))
                     break;
             }
             
-            const isMaybeTypeOnly = this.isContextual(130);
-            const isString = this.match(134);
+            const isMaybeTypeOnly = this.isContextual(126);
+            const isString = this.match(130);
             const node = this.startNode();
             
             node.local = this.parseModuleExportName();
@@ -33082,7 +33063,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseExportSpecifier(node, isString) {
-        if (this.eatContextual(93)) {
+        if (this.eatContextual(89)) {
             node.exported = this.parseModuleExportName();
         } else if (isString) {
             node.exported = this.cloneStringLiteral(node.local);
@@ -33094,7 +33075,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseModuleExportName() {
-        if (this.match(134)) {
+        if (this.match(130)) {
             const result = this.parseStringLiteral(this.state.value);
             const surrogate = loneSurrogate.exec(result.value);
             
@@ -33130,7 +33111,7 @@ var StatementParser = class extends ExpressionParser {
         if (isExport)
             return false;
         
-        return this.isContextual(105) || this.isContextual(97);
+        return this.isContextual(101) || this.isContextual(93);
     }
     
     applyImportPhase(node, isExport, phase, loc) {
@@ -33161,7 +33142,7 @@ var StatementParser = class extends ExpressionParser {
         
         const {type} = this.state;
         
-        const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;
+        const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 94 || this.lookaheadCharCode() === 102 : type !== 8;
         
         if (isImportPhase) {
             this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start);
@@ -33175,11 +33156,11 @@ var StatementParser = class extends ExpressionParser {
     isPrecedingIdImportPhase() {
         const {type} = this.state;
         
-        return tokenIsIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;
+        return tokenIsIdentifier(type) ? type !== 94 || this.lookaheadCharCode() === 102 : type !== 8;
     }
     
     parseImport(node) {
-        if (this.match(134)) {
+        if (this.match(130)) {
             return this.parseImportSourceAndAttributes(node);
         }
         
@@ -33189,13 +33170,13 @@ var StatementParser = class extends ExpressionParser {
     parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
         node.specifiers = [];
         const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
-        const parseNext = !hasDefault || this.eat(12);
+        const parseNext = !hasDefault || this.eat(8);
         const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
         
         if (parseNext && !hasStar)
             this.parseNamedImportSpecifiers(node);
         
-        this.expectContextual(98);
+        this.expectContextual(94);
         return this.parseImportSourceAndAttributes(node);
     }
     
@@ -33210,7 +33191,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseImportSource() {
-        if (!this.match(134))
+        if (!this.match(130))
             this.unexpected();
         
         return this.parseExprAtom();
@@ -33229,12 +33210,12 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseImportAttributes() {
-        this.expect(5);
+        this.expect(2);
         const attrs = [];
         const attrNames =         /* @__PURE__ */new Set();
         
         do {
-            if (this.match(8)) {
+            if (this.match(4)) {
                 break;
             }
             
@@ -33249,29 +33230,29 @@ var StatementParser = class extends ExpressionParser {
             
             attrNames.add(keyName);
             
-            if (this.match(134)) {
+            if (this.match(130)) {
                 node.key = this.parseStringLiteral(keyName);
             } else {
                 node.key = this.parseIdentifier(true);
             }
             
-            this.expect(14);
+            this.expect(10);
             
-            if (!this.match(134)) {
+            if (!this.match(130)) {
                 throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
             }
             
             node.value = this.parseStringLiteral(this.state.value);
             attrs.push(this.finishNode(node, 'ImportAttribute'));
-        } while (this.eat(12))
-        this.expect(8);
+        } while (this.eat(8))
+        this.expect(4);
         return attrs;
     }
     
     maybeParseImportAttributes(node) {
         let attributes;
         
-        if (this.match(76)) {
+        if (this.match(72)) {
             if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {
                 return;
             }
@@ -33301,10 +33282,10 @@ var StatementParser = class extends ExpressionParser {
     }
     
     maybeParseStarImportSpecifier(node) {
-        if (this.match(55)) {
+        if (this.match(51)) {
             const specifier = this.startNode();
             this.next();
-            this.expectContextual(93);
+            this.expectContextual(89);
             this.parseImportSpecifierLocal(node, specifier, 'ImportNamespaceSpecifier');
             return true;
         }
@@ -33314,24 +33295,24 @@ var StatementParser = class extends ExpressionParser {
     
     parseNamedImportSpecifiers(node) {
         let first = true;
-        this.expect(5);
-        while (!this.eat(8)) {
+        this.expect(2);
+        while (!this.eat(4)) {
             if (first) {
                 first = false;
             } else {
-                if (this.eat(14)) {
+                if (this.eat(10)) {
                     throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);
                 }
                 
-                this.expect(12);
+                this.expect(8);
                 
-                if (this.eat(8))
+                if (this.eat(4))
                     break;
             }
             
             const specifier = this.startNode();
-            const importedIsString = this.match(134);
-            const isMaybeTypeOnly = this.isContextual(130);
+            const importedIsString = this.match(130);
+            const isMaybeTypeOnly = this.isContextual(126);
             
             specifier.imported = this.parseModuleExportName();
             const importSpecifier2 = this.parseImportSpecifier(specifier, importedIsString, node.importKind === 'type' || node.importKind === 'typeof', isMaybeTypeOnly, void 0);
@@ -33340,7 +33321,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
-        if (this.eatContextual(93)) {
+        if (this.eatContextual(89)) {
             specifier.local = this.parseIdentifier();
         } else {
             const {imported} = specifier;