@putout/babel 4.1.1 → 4.3.0

package/bundle/index.js

@@ -1483,16 +1483,14 @@ typeof window !== 'undefined'
             // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
 typeof navigator !== 'undefined'
                 && navigator.userAgent
-                && (m = navigator
-                .userAgent
+                && (m = navigator.userAgent
                 .toLowerCase()
                 .match(/firefox\/(\d+)/))
                 && parseInt(m[1], 10) >= 31
                 ||             // Double check webkit in userAgent just in case we are in a worker
 typeof navigator !== 'undefined'
                 && navigator.userAgent
-                && navigator
-                .userAgent
+                && navigator.userAgent
                 .toLowerCase()
                 .match(/applewebkit\/(\d+)/);
         }
@@ -7962,7 +7960,6 @@ function isLVal(node, opts) {
     case 'MemberExpression':    
     case 'ArrayPattern':    
     case 'ObjectPattern':    
-    case 'OptionalMemberExpression':    
     case 'TSAsExpression':    
     case 'TSSatisfiesExpression':    
     case 'TSTypeAssertion':    
@@ -8262,196 +8259,15 @@ function isPrivate(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isFlow(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'AnyTypeAnnotation':    
-    case 'ArrayTypeAnnotation':    
-    case 'BooleanTypeAnnotation':    
-    case 'BooleanLiteralTypeAnnotation':    
-    case 'NullLiteralTypeAnnotation':    
-    case 'ClassImplements':    
-    case 'DeclareClass':    
-    case 'DeclareFunction':    
-    case 'DeclareInterface':    
-    case 'DeclareModule':    
-    case 'DeclareModuleExports':    
-    case 'DeclareTypeAlias':    
-    case 'DeclareOpaqueType':    
-    case 'DeclareVariable':    
-    case 'DeclareExportDeclaration':    
-    case 'DeclareExportAllDeclaration':    
-    case 'DeclaredPredicate':    
-    case 'ExistsTypeAnnotation':    
-    case 'FunctionTypeAnnotation':    
-    case 'FunctionTypeParam':    
-    case 'GenericTypeAnnotation':    
-    case 'InferredPredicate':    
-    case 'InterfaceExtends':    
-    case 'InterfaceDeclaration':    
-    case 'InterfaceTypeAnnotation':    
-    case 'IntersectionTypeAnnotation':    
-    case 'MixedTypeAnnotation':    
-    case 'EmptyTypeAnnotation':    
-    case 'NullableTypeAnnotation':    
-    case 'NumberLiteralTypeAnnotation':    
-    case 'NumberTypeAnnotation':    
-    case 'ObjectTypeAnnotation':    
-    case 'ObjectTypeInternalSlot':    
-    case 'ObjectTypeCallProperty':    
-    case 'ObjectTypeIndexer':    
-    case 'ObjectTypeProperty':    
-    case 'ObjectTypeSpreadProperty':    
-    case 'OpaqueType':    
-    case 'QualifiedTypeIdentifier':    
-    case 'StringLiteralTypeAnnotation':    
-    case 'StringTypeAnnotation':    
-    case 'SymbolTypeAnnotation':    
-    case 'ThisTypeAnnotation':    
-    case 'TupleTypeAnnotation':    
-    case 'TypeofTypeAnnotation':    
-    case 'TypeAlias':    
-    case 'TypeAnnotation':    
-    case 'TypeCastExpression':    
-    case 'TypeParameter':    
-    case 'TypeParameterDeclaration':    
-    case 'TypeParameterInstantiation':    
-    case 'UnionTypeAnnotation':    
-    case 'Variance':    
-    case 'VoidTypeAnnotation':    
-    case 'EnumDeclaration':    
-    case 'EnumBooleanBody':    
-    case 'EnumNumberBody':    
-    case 'EnumStringBody':    
-    case 'EnumSymbolBody':    
-    case 'EnumBooleanMember':    
-    case 'EnumNumberMember':    
-    case 'EnumStringMember':    
-    case 'EnumDefaultedMember':    
-    case 'IndexedAccessType':    
-    case 'OptionalIndexedAccessType':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
+function isFlow() {}
 
-function isFlowType(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'AnyTypeAnnotation':    
-    case 'ArrayTypeAnnotation':    
-    case 'BooleanTypeAnnotation':    
-    case 'BooleanLiteralTypeAnnotation':    
-    case 'NullLiteralTypeAnnotation':    
-    case 'ExistsTypeAnnotation':    
-    case 'FunctionTypeAnnotation':    
-    case 'GenericTypeAnnotation':    
-    case 'InterfaceTypeAnnotation':    
-    case 'IntersectionTypeAnnotation':    
-    case 'MixedTypeAnnotation':    
-    case 'EmptyTypeAnnotation':    
-    case 'NullableTypeAnnotation':    
-    case 'NumberLiteralTypeAnnotation':    
-    case 'NumberTypeAnnotation':    
-    case 'ObjectTypeAnnotation':    
-    case 'StringLiteralTypeAnnotation':    
-    case 'StringTypeAnnotation':    
-    case 'SymbolTypeAnnotation':    
-    case 'ThisTypeAnnotation':    
-    case 'TupleTypeAnnotation':    
-    case 'TypeofTypeAnnotation':    
-    case 'UnionTypeAnnotation':    
-    case 'VoidTypeAnnotation':    
-    case 'IndexedAccessType':    
-    case 'OptionalIndexedAccessType':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
+function isFlowType() {}
 
-function isFlowBaseAnnotation(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'AnyTypeAnnotation':    
-    case 'BooleanTypeAnnotation':    
-    case 'NullLiteralTypeAnnotation':    
-    case 'MixedTypeAnnotation':    
-    case 'EmptyTypeAnnotation':    
-    case 'NumberTypeAnnotation':    
-    case 'StringTypeAnnotation':    
-    case 'SymbolTypeAnnotation':    
-    case 'ThisTypeAnnotation':    
-    case 'VoidTypeAnnotation':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
+function isFlowBaseAnnotation() {}
 
-function isFlowDeclaration(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'DeclareClass':    
-    case 'DeclareFunction':    
-    case 'DeclareInterface':    
-    case 'DeclareModule':    
-    case 'DeclareModuleExports':    
-    case 'DeclareTypeAlias':    
-    case 'DeclareOpaqueType':    
-    case 'DeclareVariable':    
-    case 'DeclareExportDeclaration':    
-    case 'DeclareExportAllDeclaration':    
-    case 'InterfaceDeclaration':    
-    case 'OpaqueType':    
-    case 'TypeAlias':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
+function isFlowDeclaration() {}
 
-function isFlowPredicate(node, opts) {
-    if (!node)
-        return false;
-    
-    switch(node.type) {
-    case 'DeclaredPredicate':    
-    case 'InferredPredicate':
-        break;
-    
-    default:
-        return false;
-    }
-    
-    
-    return opts == null || shallowEqual(node, opts);
-}
+function isFlowPredicate() {}
 
 function isEnumBody(node, opts) {
     if (!node)
@@ -9409,7 +9225,7 @@ defineType$4('ArrayExpression', {
 defineType$4('AssignmentExpression', {
     fields: {
         operator: {
-            validate: Object.assign(function() {
+            validate: Object.assign((function() {
                 const identifier4 = assertOneOf(...ASSIGNMENT_OPERATORS);
                 const pattern = assertOneOf('=');
                 
@@ -9417,7 +9233,7 @@ defineType$4('AssignmentExpression', {
                     const validator = is('Pattern', node.left) ? pattern : identifier4;
                     validator(node, key, val);
                 };
-            }(), {
+            })(), {
                 oneOf: ASSIGNMENT_OPERATORS,
             }),
         },
@@ -9447,7 +9263,7 @@ defineType$4('BinaryExpression', {
             validate: assertOneOf(...BINARY_OPERATORS),
         },
         left: {
-            validate: function() {
+            validate: (function() {
                 const expression2 = assertNodeType('Expression');
                 const inOp = assertNodeType('Expression', 'PrivateName');
                 const validator = Object.assign(function(node, key, val) {
@@ -9458,7 +9274,7 @@ defineType$4('BinaryExpression', {
                 });
                 
                 return validator;
-            }(),
+            })(),
         },
         right: {
             validate: assertNodeType('Expression'),
@@ -9768,7 +9584,7 @@ defineType$4('FunctionDeclaration', {
         'Pureish',
         'Declaration',
     ],
-    validate: function() {
+    validate: (function() {
         const identifier4 = assertNodeType('Identifier');
         
         return function(parent, key, node) {
@@ -9776,7 +9592,7 @@ defineType$4('FunctionDeclaration', {
                 identifier4(node, 'id', node.id);
             }
         };
-    }(),
+    })(),
 });
 defineType$4('FunctionExpression', {
     inherits: 'FunctionDeclaration',
@@ -9991,7 +9807,7 @@ defineType$4('RegExpLiteral', {
         },
         flags: {
             validate: chain(assertValueType('string'), Object.assign(function(node, key, val) {
-                const invalid = /[^gimsuy]/.exec(val);
+                const invalid = /[^dgimsuvy]/.exec(val);
                 
                 if (invalid) {
                     throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
@@ -10041,7 +9857,7 @@ defineType$4('MemberExpression', {
             validate: assertNodeType('Expression', 'Super'),
         },
         property: {
-            validate: function() {
+            validate: (function() {
                 const normal = assertNodeType('Identifier', 'PrivateName');
                 const computed = assertNodeType('Expression');
                 const validator = function(node, key, val) {
@@ -10055,7 +9871,7 @@ defineType$4('MemberExpression', {
                     'PrivateName',
                 ];
                 return validator;
-            }(),
+            })(),
         },
         computed: {
             default: false,
@@ -10128,7 +9944,7 @@ defineType$4('ObjectMethod', {
             default: false,
         },
         key: {
-            validate: function() {
+            validate: (function() {
                 const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral');
                 const computed = assertNodeType('Expression');
                 const validator = function(node, key, val) {
@@ -10144,7 +9960,7 @@ defineType$4('ObjectMethod', {
                     'BigIntLiteral',
                 ];
                 return validator;
-            }(),
+            })(),
         },
         decorators: {
             validate: arrayOfType('Decorator'),
@@ -10177,7 +9993,7 @@ defineType$4('ObjectProperty', {
             default: false,
         },
         key: {
-            validate: function() {
+            validate: (function() {
                 const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'PrivateName');
                 const computed = assertNodeType('Expression');
                 const validator = Object.assign(function(node, key, val) {
@@ -10195,7 +10011,7 @@ defineType$4('ObjectProperty', {
                 });
                 
                 return validator;
-            }(),
+            })(),
         },
         value: {
             validate: assertNodeType('Expression', 'PatternLike'),
@@ -10232,7 +10048,7 @@ defineType$4('ObjectProperty', {
         'Property',
         'ObjectMember',
     ],
-    validate: function() {
+    validate: (function() {
         const pattern = assertNodeType('Identifier', 'Pattern', 'TSAsExpression', 'TSSatisfiesExpression', 'TSNonNullExpression', 'TSTypeAssertion');
         const expression2 = assertNodeType('Expression');
         
@@ -10240,7 +10056,7 @@ defineType$4('ObjectProperty', {
             const validator = is('ObjectPattern', parent) ? pattern : expression2;
             validator(node, 'value', node.value);
         };
-    }(),
+    })(),
 });
 defineType$4('RestElement', {
     visitor: ['argument', 'typeAnnotation'],
@@ -10679,7 +10495,7 @@ defineType$4('ClassDeclaration', {
             optional: true,
         },
     },
-    validate: function() {
+    validate: (function() {
         const identifier4 = assertNodeType('Identifier');
         
         return function(parent, key, node) {
@@ -10687,7 +10503,7 @@ defineType$4('ClassDeclaration', {
                 identifier4(node, 'id', node.id);
             }
         };
-    }(),
+    })(),
 });
 var importAttributes = {
     attributes: {
@@ -10770,7 +10586,7 @@ defineType$4('ExportNamedDeclaration', {
     }, importAttributes, {
         specifiers: {
             default: [],
-            validate: arrayOf(function() {
+            validate: arrayOf((function() {
                 const sourced = assertNodeType('ExportSpecifier', 'ExportDefaultSpecifier', 'ExportNamespaceSpecifier');
                 const sourceless = assertNodeType('ExportSpecifier');
                 
@@ -10784,7 +10600,7 @@ defineType$4('ExportNamedDeclaration', {
                         'ExportNamespaceSpecifier',
                     ],
                 });
-            }()),
+            })()),
         },
         source: {
             validate: assertNodeType('StringLiteral'),
@@ -10831,7 +10647,7 @@ defineType$4('ForOfStatement', {
     ],
     fields: {
         left: {
-            validate: function() {
+            validate: (function() {
                 const declaration = assertNodeType('VariableDeclaration');
                 const lval = assertNodeType('Identifier', 'MemberExpression', 'ArrayPattern', 'ObjectPattern', 'TSAsExpression', 'TSSatisfiesExpression', 'TSTypeAssertion', 'TSNonNullExpression');
                 
@@ -10854,7 +10670,7 @@ defineType$4('ForOfStatement', {
                         'TSNonNullExpression',
                     ],
                 });
-            }(),
+            })(),
         },
         right: {
             validate: assertNodeType('Expression'),
@@ -11007,7 +10823,7 @@ var classMethodOrPropertyCommon = () => ({
         optional: true,
     },
     key: {
-        validate: chain(function() {
+        validate: chain((function() {
             const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral');
             const computed = assertNodeType('Expression');
             
@@ -11015,7 +10831,7 @@ var classMethodOrPropertyCommon = () => ({
                 const validator = node.computed ? computed : normal;
                 validator(node, key, val);
             };
-        }(), assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'Expression')),
+        })(), assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'Expression')),
     },
 });
 
@@ -11241,13 +11057,13 @@ defineType$4('OptionalMemberExpression', {
         'optional',
     ],
     visitor: ['object', 'property'],
-    aliases: ['Expression', 'LVal'],
+    aliases: ['Expression'],
     fields: {
         object: {
             validate: assertNodeType('Expression'),
         },
         property: {
-            validate: function() {
+            validate: (function() {
                 const normal = assertNodeType('Identifier');
                 const computed = assertNodeType('Expression');
                 const validator = Object.assign(function(node, key, val) {
@@ -11258,7 +11074,7 @@ defineType$4('OptionalMemberExpression', {
                 });
                 
                 return validator;
-            }(),
+            })(),
         },
         computed: {
             default: false,
@@ -11360,7 +11176,7 @@ defineType$4('ClassAccessorProperty', {
     aliases: ['Property', 'Accessor'],
     fields: Object.assign({}, classMethodOrPropertyCommon(), {
         key: {
-            validate: chain(function() {
+            validate: chain((function() {
                 const normal = assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'PrivateName');
                 const computed = assertNodeType('Expression');
                 
@@ -11368,7 +11184,7 @@ defineType$4('ClassAccessorProperty', {
                     const validator = node.computed ? computed : normal;
                     validator(node, key, val);
                 };
-            }(), assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'Expression', 'PrivateName')),
+            })(), assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'Expression', 'PrivateName')),
         },
         value: {
             validate: assertNodeType('Expression'),
@@ -12774,6 +12590,7 @@ defineType('TSTypeOperator', {
     fields: {
         operator: {
             validate: assertOneOf('keyof', 'readonly', 'unique'),
+            default: void 0,
         },
         typeAnnotation: validateType('TSType'),
     },
@@ -12830,7 +12647,7 @@ defineType('TSLiteralType', {
     visitor: ['literal'],
     fields: {
         literal: {
-            validate: function() {
+            validate: (function() {
                 const unaryExpression3 = assertNodeType('NumericLiteral', 'BigIntLiteral');
                 const unaryOperator = assertOneOf('-');
                 const literal = assertNodeType('NumericLiteral', 'StringLiteral', 'BooleanLiteral', 'BigIntLiteral', 'TemplateLiteral');
@@ -12853,7 +12670,7 @@ defineType('TSLiteralType', {
                     'UnaryExpression',
                 ];
                 return validator;
-            }(),
+            })(),
         },
     },
 });
@@ -19137,8 +18954,7 @@ function getNameFromLiteralId(id) {
     }
     
     if (isTemplateLiteral(id)) {
-        return id
-            .quasis
+        return id.quasis
             .map((quasi) => quasi.value.raw)
             .join('');
     }
@@ -20337,7 +20153,6 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
             this.castNodeTo(node, 'ImportExpression');
             node.source = node.arguments[0];
             node.options = node.arguments[1] ?? null;
-            node.attributes = node.arguments[1] ?? null;
             delete node.arguments;
             delete node.callee;
         } else if (node.type === 'OptionalCallExpression') {
@@ -22150,3262 +21965,323 @@ var reservedWordLikeSet = /* @__PURE__ */new Set([
     'import',
     'null',
     'true',
-    'false',
-    'in',
-    'instanceof',
-    'typeof',
-    'void',
-    'delete',
-    'implements',
-    'interface',
-    'let',
-    'package',
-    'private',
-    'protected',
-    'public',
-    'static',
-    'yield',
-    'eval',
-    'arguments',
-    'enum',
-    'await',
-]);
-
-function canBeReservedWord(word) {
-    return reservedWordLikeSet.has(word);
-}
-
-var Scope = class {
-    constructor(flags) {
-        __publicField(this, 'flags', 0);
-        __publicField(this, 'names',         /* @__PURE__ */new Map());
-        __publicField(this, 'firstLexicalName', '');
-        this.flags = flags;
-    }
-};
-
-var ScopeHandler = class {
-    constructor(parser, inModule) {
-        __publicField(this, 'parser');
-        __publicField(this, 'scopeStack', []);
-        __publicField(this, 'inModule');
-        __publicField(this, 'undefinedExports',         /* @__PURE__ */new Map());
-        this.parser = parser;
-        this.inModule = inModule;
-    }
-    
-    get inTopLevel() {
-        return (this.currentScope().flags & 1) > 0;
-    }
-    
-    get inFunction() {
-        return (this.currentVarScopeFlags() & 2) > 0;
-    }
-    
-    get allowSuper() {
-        return (this.currentThisScopeFlags() & 16) > 0;
-    }
-    
-    get allowDirectSuper() {
-        return (this.currentThisScopeFlags() & 32) > 0;
-    }
-    
-    get allowNewTarget() {
-        return (this.currentThisScopeFlags() & 512) > 0;
-    }
-    
-    get inClass() {
-        return (this.currentThisScopeFlags() & 64) > 0;
-    }
-    
-    get inClassAndNotInNonArrowFunction() {
-        const flags = this.currentThisScopeFlags();
-        return (flags & 64) > 0 && (flags & 2) === 0;
-    }
-    
-    get inStaticBlock() {
-        for (let i = this.scopeStack.length - 1;; i--) {
-            const {flags} = this.scopeStack[i];
-            
-            if (flags & 128) {
-                return true;
-            }
-            
-            if (flags & (1667 | 64)) {
-                return false;
-            }
-        }
-    }
-    
-    get inNonArrowFunction() {
-        return (this.currentThisScopeFlags() & 2) > 0;
-    }
-    
-    get inBareCaseStatement() {
-        return (this.currentScope().flags & 256) > 0;
-    }
-    
-    get treatFunctionsAsVar() {
-        return this.treatFunctionsAsVarInScope(this.currentScope());
-    }
-    
-    createScope(flags) {
-        return new Scope(flags);
-    }
-    
-    enter(flags) {
-        this.scopeStack.push(this.createScope(flags));
-    }
-    
-    exit() {
-        const scope2 = this.scopeStack.pop();
-        return scope2.flags;
-    }
-    
-    treatFunctionsAsVarInScope(scope2) {
-        return !!(scope2.flags & (2 | 128) || !this.parser.inModule && scope2.flags & 1);
-    }
-    
-    declareName(name, bindingType, loc) {
-        let scope2 = this.currentScope();
-        
-        if (bindingType & 8 || bindingType & 16) {
-            this.checkRedeclarationInScope(scope2, name, bindingType, loc);
-            let type = scope2.names.get(name) || 0;
-            
-            if (bindingType & 16) {
-                type = type | 4;
-            } else {
-                if (!scope2.firstLexicalName) {
-                    scope2.firstLexicalName = name;
-                }
-                
-                type = type | 2;
-            }
-            
-            scope2.names.set(name, type);
-            
-            if (bindingType & 8) {
-                this.maybeExportDefined(scope2, name);
-            }
-        } else if (bindingType & 4) {
-            for (let i = this.scopeStack.length - 1; i >= 0; --i) {
-                scope2 = this.scopeStack[i];
-                this.checkRedeclarationInScope(scope2, name, bindingType, loc);
-                scope2.names.set(name, (scope2.names.get(name) || 0) | 1);
-                this.maybeExportDefined(scope2, name);
-                
-                if (scope2.flags & 1667)
-                    break;
-            }
-        }
-        
-        if (this.parser.inModule && scope2.flags & 1) {
-            this.undefinedExports.delete(name);
-        }
-    }
-    
-    maybeExportDefined(scope2, name) {
-        if (this.parser.inModule && scope2.flags & 1) {
-            this.undefinedExports.delete(name);
-        }
-    }
-    
-    checkRedeclarationInScope(scope2, name, bindingType, loc) {
-        if (this.isRedeclaredInScope(scope2, name, bindingType)) {
-            this.parser.raise(Errors.VarRedeclaration, loc, {
-                identifierName: name,
-            });
-        }
-    }
-    
-    isRedeclaredInScope(scope2, name, bindingType) {
-        if (!(bindingType & 1))
-            return false;
-        
-        if (bindingType & 8) {
-            return scope2.names.has(name);
-        }
-        
-        const type = scope2.names.get(name);
-        
-        if (bindingType & 16) {
-            return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope2) && (type & 1) > 0;
-        }
-        
-        return (type & 2) > 0 && !(scope2.flags & 8 && scope2.firstLexicalName === name)
-            || !this.treatFunctionsAsVarInScope(scope2) && (type & 4) > 0;
-    }
-    
-    checkLocalExport(id) {
-        const {name} = id;
-        
-        const topLevelScope = this.scopeStack[0];
-        
-        if (!topLevelScope.names.has(name)) {
-            this.undefinedExports.set(name, id.loc.start);
-        }
-    }
-    
-    currentScope() {
-        return this.scopeStack[this.scopeStack.length - 1];
-    }
-    
-    currentVarScopeFlags() {
-        for (let i = this.scopeStack.length - 1;; i--) {
-            const {flags} = this.scopeStack[i];
-            
-            if (flags & 1667) {
-                return flags;
-            }
-        }
-    }
-    
-    currentThisScopeFlags() {
-        for (let i = this.scopeStack.length - 1;; i--) {
-            const {flags} = this.scopeStack[i];
-            
-            if (flags & (1667 | 64) && !(flags & 4)) {
-                return flags;
-            }
-        }
-    }
-};
-
-var FlowScope = class extends Scope {
-    constructor() {
-        super(...arguments);
-        __publicField(this, 'declareFunctions',         /* @__PURE__ */new Set());
-    }
-};
-
-var FlowScopeHandler = class extends ScopeHandler {
-    createScope(flags) {
-        return new FlowScope(flags);
-    }
-    
-    declareName(name, bindingType, loc) {
-        const scope2 = this.currentScope();
-        
-        if (bindingType & 2048) {
-            this.checkRedeclarationInScope(scope2, name, bindingType, loc);
-            this.maybeExportDefined(scope2, name);
-            scope2.declareFunctions.add(name);
-            return;
-        }
-        
-        super.declareName(name, bindingType, loc);
-    }
-    
-    isRedeclaredInScope(scope2, name, bindingType) {
-        if (super.isRedeclaredInScope(scope2, name, bindingType))
-            return true;
-        
-        if (bindingType & 2048 && !scope2.declareFunctions.has(name)) {
-            const type = scope2.names.get(name);
-            return (type & 4) > 0 || (type & 2) > 0;
-        }
-        
-        return false;
-    }
-    
-    checkLocalExport(id) {
-        if (!this.scopeStack[0].declareFunctions.has(id.name)) {
-            super.checkLocalExport(id);
-        }
-    }
-};
-
-var reservedTypes = /* @__PURE__ */new Set([
-    '_',
-    'any',
-    'bool',
-    'boolean',
-    'empty',
-    'extends',
-    'false',
-    'interface',
-    'mixed',
-    'null',
-    'number',
-    'static',
-    'string',
-    'true',
-    'typeof',
-    'void',
-]);
-
-var FlowErrors = ParseErrorEnum`flow`({
-    AmbiguousConditionalArrow: 'Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.',
-    AmbiguousDeclareModuleKind: 'Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.',
-    AssignReservedType: ({reservedType}) => `Cannot overwrite reserved type ${reservedType}.`,
-    DeclareClassElement: 'The `declare` modifier can only appear on class fields.',
-    DeclareClassFieldInitializer: 'Initializers are not allowed in fields with the `declare` modifier.',
-    DuplicateDeclareModuleExports: 'Duplicate `declare module.exports` statement.',
-    EnumBooleanMemberNotInitialized: ({memberName, enumName}) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
-    EnumDuplicateMemberName: ({memberName, enumName}) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
-    EnumInconsistentMemberValues: ({enumName}) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
-    EnumInvalidExplicitType: ({invalidEnumType, enumName}) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-    EnumInvalidExplicitTypeUnknownSupplied: ({enumName}) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-    EnumInvalidMemberInitializerPrimaryType: ({enumName, memberName, explicitType}) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
-    EnumInvalidMemberInitializerSymbolType: ({enumName, memberName}) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
-    EnumInvalidMemberInitializerUnknownType: ({enumName, memberName}) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
-    EnumInvalidMemberName: ({enumName, memberName, suggestion}) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
-    EnumNumberMemberNotInitialized: ({enumName, memberName}) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
-    EnumStringMemberInconsistentlyInitialized: ({enumName}) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
-    GetterMayNotHaveThisParam: 'A getter cannot have a `this` parameter.',
-    ImportReflectionHasImportType: 'An `import module` declaration can not use `type` or `typeof` keyword.',
-    ImportTypeShorthandOnlyInPureImport: 'The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.',
-    InexactInsideExact: 'Explicit inexact syntax cannot appear inside an explicit exact object type.',
-    InexactInsideNonObject: 'Explicit inexact syntax cannot appear in class or interface definitions.',
-    InexactVariance: 'Explicit inexact syntax cannot have variance.',
-    InvalidNonTypeImportInDeclareModule: 'Imports within a `declare module` body must always be `import type` or `import typeof`.',
-    MissingTypeParamDefault: 'Type parameter declaration needs a default, since a preceding type parameter declaration has a default.',
-    NestedDeclareModule: '`declare module` cannot be used inside another `declare module`.',
-    NestedFlowComment: 'Cannot have a flow comment inside another flow comment.',
-    PatternIsOptional: Object.assign({
-        message: 'A binding pattern parameter cannot be optional in an implementation signature.',
-    }, {}),
-    SetterMayNotHaveThisParam: 'A setter cannot have a `this` parameter.',
-    SpreadVariance: 'Spread properties cannot have variance.',
-    ThisParamAnnotationRequired: 'A type annotation is required for the `this` parameter.',
-    ThisParamBannedInConstructor: 'Constructors cannot have a `this` parameter; constructors don\'t bind `this` like other functions.',
-    ThisParamMayNotBeOptional: 'The `this` parameter cannot be optional.',
-    ThisParamMustBeFirst: 'The `this` parameter must be the first function parameter.',
-    ThisParamNoDefault: 'The `this` parameter may not have a default value.',
-    TypeBeforeInitializer: 'Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.',
-    TypeCastInPattern: 'The type cast expression is expected to be wrapped with parenthesis.',
-    UnexpectedExplicitInexactInObject: 'Explicit inexact syntax must appear at the end of an inexact object.',
-    UnexpectedReservedType: ({reservedType}) => `Unexpected reserved type ${reservedType}.`,
-    UnexpectedReservedUnderscore: '`_` is only allowed as a type argument to call or new.',
-    UnexpectedSpaceBetweenModuloChecks: 'Spaces between `%` and `checks` are not allowed here.',
-    UnexpectedSpreadType: 'Spread operator cannot appear in class or interface definitions.',
-    UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".',
-    UnexpectedTokenAfterTypeParameter: 'Expected an arrow function after this type parameter declaration.',
-    UnexpectedTypeParameterBeforeAsyncArrowFunction: 'Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.',
-    UnsupportedDeclareExportKind: ({unsupportedExportKind, suggestion}) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
-    UnsupportedStatementInDeclareModule: 'Only declares and type imports are allowed inside declare module.',
-    UnterminatedFlowComment: 'Unterminated flow-comment.',
-});
-
-function isEsModuleType(bodyElement) {
-    return bodyElement.type === 'DeclareExportAllDeclaration'
-        || bodyElement.type === 'DeclareExportDeclaration'
-        && (!bodyElement.declaration
-        || bodyElement.declaration.type !== 'TypeAlias'
-        && bodyElement.declaration.type !== 'InterfaceDeclaration');
-}
-
-function hasTypeImportKind(node) {
-    return node.importKind === 'type' || node.importKind === 'typeof';
-}
-
-var exportSuggestions = {
-    const: 'declare export var',
-    let: 'declare export var',
-    type: 'export type',
-    interface: 'export interface',
-};
-
-function partition(list, test) {
-    const list1 = [];
-    const list2 = [];
-    
-    for (let i = 0; i < list.length; i++) {
-        (test(list[i], i, list) ? list1 : list2).push(list[i]);
-    }
-    
-    return [list1, list2];
-}
-
-var FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
-
-var flow = (superClass) => class FlowParserMixin extends superClass {
-    constructor() {
-        super(...arguments);
-        __publicField(this, 'flowPragma');
-    }
-    
-    getScopeHandler() {
-        return FlowScopeHandler;
-    }
-    
-    shouldParseTypes() {
-        return this.getPluginOption('flow', 'all') || this.flowPragma === 'flow';
-    }
-    
-    finishToken(type, val) {
-        if (type !== 134 && type !== 13 && type !== 28) {
-            if (this.flowPragma === void 0) {
-                this.flowPragma = null;
-            }
-        }
-        
-        super.finishToken(type, val);
-    }
-    
-    addComment(comment) {
-        if (this.flowPragma === void 0) {
-            const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
-            
-            if (!matches); else if (matches[1] === 'flow') {
-                this.flowPragma = 'flow';
-            } else if (matches[1] === 'noflow') {
-                this.flowPragma = 'noflow';
-            } else {
-                throw new Error('Unexpected flow pragma');
-            }
-
-        }
-        
-        super.addComment(comment);
-    }
-    
-    flowParseTypeInitialiser(tok) {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        this.expect(tok || 14);
-        const type = this.flowParseType();
-        
-        this.state.inType = oldInType;
-        return type;
-    }
-    
-    flowParsePredicate() {
-        const node = this.startNode();
-        const moduloLoc = this.state.startLoc;
-        this.next();
-        this.expectContextual(110);
-        
-        if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {
-            this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
-        }
-        
-        if (this.eat(10)) {
-            node.value = super.parseExpression();
-            this.expect(11);
-            return this.finishNode(node, 'DeclaredPredicate');
-        } else {
-            return this.finishNode(node, 'InferredPredicate');
-        }
-    }
-    
-    flowParseTypeAndPredicateInitialiser() {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        this.expect(14);
-        let type = null;
-        let predicate = null;
-        
-        if (this.match(54)) {
-            this.state.inType = oldInType;
-            predicate = this.flowParsePredicate();
-        } else {
-            type = this.flowParseType();
-            this.state.inType = oldInType;
-            
-            if (this.match(54)) {
-                predicate = this.flowParsePredicate();
-            }
-        }
-        
-        return [type, predicate];
-    }
-    
-    flowParseDeclareClass(node) {
-        this.next();
-        this.flowParseInterfaceish(node, true);
-        return this.finishNode(node, 'DeclareClass');
-    }
-    
-    flowParseDeclareFunction(node) {
-        this.next();
-        const id = node.id = this.parseIdentifier();
-        const typeNode = this.startNode();
-        const typeContainer = this.startNode();
-        
-        if (this.match(47)) {
-            typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            typeNode.typeParameters = null;
-        }
-        
-        this.expect(10);
-        const tmp = this.flowParseFunctionTypeParams();
-        
-        typeNode.params = tmp.params;
-        typeNode.rest = tmp.rest;
-        typeNode.this = tmp._this;
-        this.expect(11);
-        [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-        typeContainer.typeAnnotation = this.finishNode(typeNode, 'FunctionTypeAnnotation');
-        id.typeAnnotation = this.finishNode(typeContainer, 'TypeAnnotation');
-        this.resetEndLocation(id);
-        this.semicolon();
-        this.scope.declareName(node.id.name, 2048, node.id.loc.start);
-        return this.finishNode(node, 'DeclareFunction');
-    }
-    
-    flowParseDeclare(node, insideModule) {
-        if (this.match(80)) {
-            return this.flowParseDeclareClass(node);
-        } else if (this.match(68)) {
-            return this.flowParseDeclareFunction(node);
-        } else if (this.match(74)) {
-            return this.flowParseDeclareVariable(node);
-        } else if (this.eatContextual(127)) {
-            if (this.match(16)) {
-                return this.flowParseDeclareModuleExports(node);
-            } else {
-                if (insideModule) {
-                    this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);
-                }
-                
-                return this.flowParseDeclareModule(node);
-            }
-        } else if (this.isContextual(130)) {
-            return this.flowParseDeclareTypeAlias(node);
-        } else if (this.isContextual(131)) {
-            return this.flowParseDeclareOpaqueType(node);
-        } else if (this.isContextual(129)) {
-            return this.flowParseDeclareInterface(node);
-        } else if (this.match(82)) {
-            return this.flowParseDeclareExportDeclaration(node, insideModule);
-        } else {
-            this.unexpected();
-        }
-
-
-
-
-
-
-    }
-    
-    flowParseDeclareVariable(node) {
-        this.next();
-        node.id = this.flowParseTypeAnnotatableIdentifier(true);
-        this.scope.declareName(node.id.name, 5, node.id.loc.start);
-        this.semicolon();
-        return this.finishNode(node, 'DeclareVariable');
-    }
-    
-    flowParseDeclareModule(node) {
-        this.scope.enter(0);
-        
-        if (this.match(134)) {
-            node.id = super.parseExprAtom();
-        } else {
-            node.id = this.parseIdentifier();
-        }
-        
-        const bodyNode = node.body = this.startNode();
-        const body = bodyNode.body = [];
-        
-        this.expect(5);
-        while (!this.match(8)) {
-            let bodyNode2 = this.startNode();
-            
-            if (this.match(83)) {
-                this.next();
-                
-                if (!this.isContextual(130) && !this.match(87)) {
-                    this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
-                }
-                
-                super.parseImport(bodyNode2);
-            } else {
-                this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);
-                bodyNode2 = this.flowParseDeclare(bodyNode2, true);
-            }
-            
-            body.push(bodyNode2);
-        }
-        
-        this.scope.exit();
-        this.expect(8);
-        this.finishNode(bodyNode, 'BlockStatement');
-        let kind = null;
-        let hasModuleExport = false;
-        
-        body.forEach((bodyElement) => {
-            if (isEsModuleType(bodyElement)) {
-                if (kind === 'CommonJS') {
-                    this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
-                }
-                
-                kind = 'ES';
-            } else if (bodyElement.type === 'DeclareModuleExports') {
-                if (hasModuleExport) {
-                    this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);
-                }
-                
-                if (kind === 'ES') {
-                    this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
-                }
-                
-                kind = 'CommonJS';
-                hasModuleExport = true;
-            }
-        });
-        node.kind = kind || 'CommonJS';
-        return this.finishNode(node, 'DeclareModule');
-    }
-    
-    flowParseDeclareExportDeclaration(node, insideModule) {
-        this.expect(82);
-        
-        if (this.eat(65)) {
-            if (this.match(68) || this.match(80)) {
-                node.declaration = this.flowParseDeclare(this.startNode());
-            } else {
-                node.declaration = this.flowParseType();
-                this.semicolon();
-            }
-            
-            node.default = true;
-            return this.finishNode(node, 'DeclareExportDeclaration');
-        } else {
-            if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {
-                const label = this.state.value;
-                
-                throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
-                    unsupportedExportKind: label,
-                    suggestion: exportSuggestions[label],
-                });
-            }
-            
-            if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {
-                node.declaration = this.flowParseDeclare(this.startNode());
-                node.default = false;
-                return this.finishNode(node, 'DeclareExportDeclaration');
-            } else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {
-                node = this.parseExport(node, null);
-                
-                if (node.type === 'ExportNamedDeclaration') {
-                    node.default = false;
-                    delete node.exportKind;
-                    return this.castNodeTo(node, 'DeclareExportDeclaration');
-                } else {
-                    return this.castNodeTo(node, 'DeclareExportAllDeclaration');
-                }
-            }
-        }
-        
-        this.unexpected();
-    }
-    
-    flowParseDeclareModuleExports(node) {
-        this.next();
-        this.expectContextual(111);
-        node.typeAnnotation = this.flowParseTypeAnnotation();
-        this.semicolon();
-        return this.finishNode(node, 'DeclareModuleExports');
-    }
-    
-    flowParseDeclareTypeAlias(node) {
-        this.next();
-        const finished = this.flowParseTypeAlias(node);
-        this.castNodeTo(finished, 'DeclareTypeAlias');
-        return finished;
-    }
-    
-    flowParseDeclareOpaqueType(node) {
-        this.next();
-        const finished = this.flowParseOpaqueType(node, true);
-        this.castNodeTo(finished, 'DeclareOpaqueType');
-        return finished;
-    }
-    
-    flowParseDeclareInterface(node) {
-        this.next();
-        this.flowParseInterfaceish(node, false);
-        return this.finishNode(node, 'DeclareInterface');
-    }
-    
-    flowParseInterfaceish(node, isClass3) {
-        node.id = this.flowParseRestrictedIdentifier(!isClass3, true);
-        this.scope.declareName(node.id.name, isClass3 ? 17 : 8201, node.id.loc.start);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        node.extends = [];
-        
-        if (this.eat(81)) {
-            do {
-                node.extends.push(this.flowParseInterfaceExtends());
-            } while (!isClass3 && this.eat(12))
-        }
-        
-        if (isClass3) {
-            node.implements = [];
-            node.mixins = [];
-            
-            if (this.eatContextual(117)) {
-                do {
-                    node.mixins.push(this.flowParseInterfaceExtends());
-                } while (this.eat(12))
-            }
-            
-            if (this.eatContextual(113)) {
-                do {
-                    node.implements.push(this.flowParseInterfaceExtends());
-                } while (this.eat(12))
-            }
-        }
-        
-        node.body = this.flowParseObjectType({
-            allowStatic: isClass3,
-            allowExact: false,
-            allowSpread: false,
-            allowProto: isClass3,
-            allowInexact: false,
-        });
-    }
-    
-    flowParseInterfaceExtends() {
-        const node = this.startNode();
-        
-        node.id = this.flowParseQualifiedTypeIdentifier();
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterInstantiation();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        return this.finishNode(node, 'InterfaceExtends');
-    }
-    
-    flowParseInterface(node) {
-        this.flowParseInterfaceish(node, false);
-        return this.finishNode(node, 'InterfaceDeclaration');
-    }
-    
-    checkNotUnderscore(word) {
-        if (word === '_') {
-            this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);
-        }
-    }
-    
-    checkReservedType(word, startLoc, declaration) {
-        if (!reservedTypes.has(word))
-            return;
-        
-        this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, {
-            reservedType: word,
-        });
-    }
-    
-    flowParseRestrictedIdentifier(liberal, declaration) {
-        this.checkReservedType(this.state.value, this.state.startLoc, declaration);
-        return this.parseIdentifier(liberal);
-    }
-    
-    flowParseTypeAlias(node) {
-        node.id = this.flowParseRestrictedIdentifier(false, true);
-        this.scope.declareName(node.id.name, 8201, node.id.loc.start);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        node.right = this.flowParseTypeInitialiser(29);
-        this.semicolon();
-        return this.finishNode(node, 'TypeAlias');
-    }
-    
-    flowParseOpaqueType(node, declare) {
-        this.expectContextual(130);
-        node.id = this.flowParseRestrictedIdentifier(true, true);
-        this.scope.declareName(node.id.name, 8201, node.id.loc.start);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        } else {
-            node.typeParameters = null;
-        }
-        
-        node.supertype = null;
-        
-        if (this.match(14)) {
-            node.supertype = this.flowParseTypeInitialiser(14);
-        }
-        
-        node.impltype = null;
-        
-        if (!declare) {
-            node.impltype = this.flowParseTypeInitialiser(29);
-        }
-        
-        this.semicolon();
-        return this.finishNode(node, 'OpaqueType');
-    }
-    
-    flowParseTypeParameter(requireDefault = false) {
-        const nodeStartLoc = this.state.startLoc;
-        const node = this.startNode();
-        const variance2 = this.flowParseVariance();
-        const ident = this.flowParseTypeAnnotatableIdentifier();
-        
-        node.name = ident.name;
-        node.variance = variance2;
-        node.bound = ident.typeAnnotation;
-        
-        if (this.match(29)) {
-            this.eat(29);
-            node.default = this.flowParseType();
-        } else {
-            if (requireDefault) {
-                this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
-            }
-        }
-        
-        return this.finishNode(node, 'TypeParameter');
-    }
-    
-    flowParseTypeParameterDeclaration() {
-        const oldInType = this.state.inType;
-        const node = this.startNode();
-        
-        node.params = [];
-        this.state.inType = true;
-        
-        if (this.match(47) || this.match(143)) {
-            this.next();
-        } else {
-            this.unexpected();
-        }
-        
-        let defaultRequired = false;
-        
-        do {
-            const typeParameter2 = this.flowParseTypeParameter(defaultRequired);
-            node.params.push(typeParameter2);
-            
-            if (typeParameter2.default) {
-                defaultRequired = true;
-            }
-            
-            if (!this.match(48)) {
-                this.expect(12);
-            }
-        } while (!this.match(48))
-        this.expect(48);
-        this.state.inType = oldInType;
-        return this.finishNode(node, 'TypeParameterDeclaration');
-    }
-    
-    flowInTopLevelContext(cb) {
-        if (this.curContext() !== types.brace) {
-            const oldContext = this.state.context;
-            
-            this.state.context = [oldContext[0]];
-            try {
-                return cb();
-            } finally {
-                this.state.context = oldContext;
-            }
-        } else {
-            return cb();
-        }
-    }
-    
-    flowParseTypeParameterInstantiationInExpression() {
-        if (this.reScan_lt() !== 47)
-            return;
-        
-        return this.flowParseTypeParameterInstantiation();
-    }
-    
-    flowParseTypeParameterInstantiation() {
-        const node = this.startNode();
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        node.params = [];
-        this.flowInTopLevelContext(() => {
-            this.expect(47);
-            const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-            
-            this.state.noAnonFunctionType = false;
-            while (!this.match(48)) {
-                node.params.push(this.flowParseType());
-                
-                if (!this.match(48)) {
-                    this.expect(12);
-                }
-            }
-            
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-        });
-        this.state.inType = oldInType;
-        
-        if (!this.state.inType && this.curContext() === types.brace) {
-            this.reScan_lt_gt();
-        }
-        
-        this.expect(48);
-        return this.finishNode(node, 'TypeParameterInstantiation');
-    }
-    
-    flowParseTypeParameterInstantiationCallOrNew() {
-        if (this.reScan_lt() !== 47)
-            return;
-        
-        const node = this.startNode();
-        const oldInType = this.state.inType;
-        
-        node.params = [];
-        this.state.inType = true;
-        this.expect(47);
-        while (!this.match(48)) {
-            node.params.push(this.flowParseTypeOrImplicitInstantiation());
-            
-            if (!this.match(48)) {
-                this.expect(12);
-            }
-        }
-        
-        this.expect(48);
-        this.state.inType = oldInType;
-        return this.finishNode(node, 'TypeParameterInstantiation');
-    }
-    
-    flowParseInterfaceType() {
-        const node = this.startNode();
-        this.expectContextual(129);
-        node.extends = [];
-        
-        if (this.eat(81)) {
-            do {
-                node.extends.push(this.flowParseInterfaceExtends());
-            } while (this.eat(12))
-        }
-        
-        node.body = this.flowParseObjectType({
-            allowStatic: false,
-            allowExact: false,
-            allowSpread: false,
-            allowProto: false,
-            allowInexact: false,
-        });
-        return this.finishNode(node, 'InterfaceTypeAnnotation');
-    }
-    
-    flowParseObjectPropertyKey() {
-        return this.match(135) || this.match(134) ? super.parseExprAtom() : this.parseIdentifier(true);
-    }
-    
-    flowParseObjectTypeIndexer(node, isStatic2, variance2) {
-        node.static = isStatic2;
-        
-        if (this.lookahead().type === 14) {
-            node.id = this.flowParseObjectPropertyKey();
-            node.key = this.flowParseTypeInitialiser();
-        } else {
-            node.id = null;
-            node.key = this.flowParseType();
-        }
-        
-        this.expect(3);
-        node.value = this.flowParseTypeInitialiser();
-        node.variance = variance2;
-        return this.finishNode(node, 'ObjectTypeIndexer');
-    }
-    
-    flowParseObjectTypeInternalSlot(node, isStatic2) {
-        node.static = isStatic2;
-        node.id = this.flowParseObjectPropertyKey();
-        this.expect(3);
-        this.expect(3);
-        
-        if (this.match(47) || this.match(10)) {
-            node.method = true;
-            node.optional = false;
-            node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
-        } else {
-            node.method = false;
-            
-            if (this.eat(17)) {
-                node.optional = true;
-            }
-            
-            node.value = this.flowParseTypeInitialiser();
-        }
-        
-        return this.finishNode(node, 'ObjectTypeInternalSlot');
-    }
-    
-    flowParseObjectTypeMethodish(node) {
-        node.params = [];
-        node.rest = null;
-        node.typeParameters = null;
-        node.this = null;
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        this.expect(10);
-        
-        if (this.match(78)) {
-            node.this = this.flowParseFunctionTypeParam(true);
-            node.this.name = null;
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        while (!this.match(11) && !this.match(21)) {
-            node.params.push(this.flowParseFunctionTypeParam(false));
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        if (this.eat(21)) {
-            node.rest = this.flowParseFunctionTypeParam(false);
-        }
-        
-        this.expect(11);
-        node.returnType = this.flowParseTypeInitialiser();
-        return this.finishNode(node, 'FunctionTypeAnnotation');
-    }
-    
-    flowParseObjectTypeCallProperty(node, isStatic2) {
-        const valueNode = this.startNode();
-        
-        node.static = isStatic2;
-        node.value = this.flowParseObjectTypeMethodish(valueNode);
-        return this.finishNode(node, 'ObjectTypeCallProperty');
-    }
-    
-    flowParseObjectType({allowStatic, allowExact, allowSpread, allowProto, allowInexact}) {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        const nodeStart = this.startNode();
-        
-        nodeStart.callProperties = [];
-        nodeStart.properties = [];
-        nodeStart.indexers = [];
-        nodeStart.internalSlots = [];
-        let endDelim;
-        let exact;
-        let inexact = false;
-        
-        if (allowExact && this.match(6)) {
-            this.expect(6);
-            endDelim = 9;
-            exact = true;
-        } else {
-            this.expect(5);
-            endDelim = 8;
-            exact = false;
-        }
-        
-        nodeStart.exact = exact;
-        while (!this.match(endDelim)) {
-            let isStatic2 = false;
-            let protoStartLoc = null;
-            let inexactStartLoc = null;
-            const node = this.startNode();
-            
-            if (allowProto && this.isContextual(118)) {
-                const lookahead = this.lookahead();
-                
-                if (lookahead.type !== 14 && lookahead.type !== 17) {
-                    this.next();
-                    protoStartLoc = this.state.startLoc;
-                    allowStatic = false;
-                }
-            }
-            
-            if (allowStatic && this.isContextual(106)) {
-                const lookahead = this.lookahead();
-                
-                if (lookahead.type !== 14 && lookahead.type !== 17) {
-                    this.next();
-                    isStatic2 = true;
-                }
-            }
-            
-            const variance2 = this.flowParseVariance();
-            
-            if (this.eat(0)) {
-                if (protoStartLoc != null) {
-                    this.unexpected(protoStartLoc);
-                }
-                
-                if (this.eat(0)) {
-                    if (variance2) {
-                        this.unexpected(variance2.loc.start);
-                    }
-                    
-                    nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic2));
-                } else {
-                    nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic2, variance2));
-                }
-            } else if (this.match(10) || this.match(47)) {
-                if (protoStartLoc != null) {
-                    this.unexpected(protoStartLoc);
-                }
-                
-                if (variance2) {
-                    this.unexpected(variance2.loc.start);
-                }
-                
-                nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic2));
-            } else {
-                let kind = 'init';
-                
-                if (this.isContextual(99) || this.isContextual(104)) {
-                    const lookahead = this.lookahead();
-                    
-                    if (tokenIsLiteralPropertyName(lookahead.type)) {
-                        kind = this.state.value;
-                        this.next();
-                    }
-                }
-                
-                const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic2, protoStartLoc, variance2, kind, allowSpread, allowInexact ?? !exact);
-                
-                if (propOrInexact === null) {
-                    inexact = true;
-                    inexactStartLoc = this.state.lastTokStartLoc;
-                } else {
-                    nodeStart.properties.push(propOrInexact);
-                }
-            }
-            
-            this.flowObjectTypeSemicolon();
-            
-            if (inexactStartLoc && !this.match(8) && !this.match(9)) {
-                this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
-            }
-        }
-        
-        this.expect(endDelim);
-        
-        if (allowSpread) {
-            nodeStart.inexact = inexact;
-        }
-        
-        const out = this.finishNode(nodeStart, 'ObjectTypeAnnotation');
-        
-        this.state.inType = oldInType;
-        return out;
-    }
-    
-    flowParseObjectTypeProperty(node, isStatic2, protoStartLoc, variance2, kind, allowSpread, allowInexact) {
-        if (this.eat(21)) {
-            const isInexactToken = this.match(12)
-                || this.match(13)
-                || this.match(8)
-                || this.match(9);
-            
-            if (isInexactToken) {
-                if (!allowSpread) {
-                    this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);
-                } else if (!allowInexact) {
-                    this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);
-                }
-                
-                if (variance2) {
-                    this.raise(FlowErrors.InexactVariance, variance2);
-                }
-                
-                return null;
-            }
-            
-            if (!allowSpread) {
-                this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);
-            }
-            
-            if (protoStartLoc != null) {
-                this.unexpected(protoStartLoc);
-            }
-            
-            if (variance2) {
-                this.raise(FlowErrors.SpreadVariance, variance2);
-            }
-            
-            node.argument = this.flowParseType();
-            return this.finishNode(node, 'ObjectTypeSpreadProperty');
-        } else {
-            node.key = this.flowParseObjectPropertyKey();
-            node.static = isStatic2;
-            node.proto = protoStartLoc != null;
-            node.kind = kind;
-            let optional = false;
-            
-            if (this.match(47) || this.match(10)) {
-                node.method = true;
-                
-                if (protoStartLoc != null) {
-                    this.unexpected(protoStartLoc);
-                }
-                
-                if (variance2) {
-                    this.unexpected(variance2.loc.start);
-                }
-                
-                node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
-                
-                if (kind === 'get' || kind === 'set') {
-                    this.flowCheckGetterSetterParams(node);
-                }
-                
-                if (!allowSpread && node.key.name === 'constructor' && node.value.this) {
-                    this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);
-                }
-            } else {
-                if (kind !== 'init')
-                    this.unexpected();
-                
-                node.method = false;
-                
-                if (this.eat(17)) {
-                    optional = true;
-                }
-                
-                node.value = this.flowParseTypeInitialiser();
-                node.variance = variance2;
-            }
-            
-            node.optional = optional;
-            return this.finishNode(node, 'ObjectTypeProperty');
-        }
-    }
-    
-    flowCheckGetterSetterParams(property) {
-        const paramCount = property.kind === 'get' ? 0 : 1;
-        const length = property.value.params.length + (property.value.rest ? 1 : 0);
-        
-        if (property.value.this) {
-            this.raise(property.kind === 'get' ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this);
-        }
-        
-        if (length !== paramCount) {
-            this.raise(property.kind === 'get' ? Errors.BadGetterArity : Errors.BadSetterArity, property);
-        }
-        
-        if (property.kind === 'set' && property.value.rest) {
-            this.raise(Errors.BadSetterRestParameter, property);
-        }
-    }
-    
-    flowObjectTypeSemicolon() {
-        if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
-            this.unexpected();
-        }
-    }
-    
-    flowParseQualifiedTypeIdentifier(startLoc, id) {
-        startLoc ?? (startLoc = this.state.startLoc);
-        let node = id || this.flowParseRestrictedIdentifier(true);
-        
-        while (this.eat(16)) {
-            const node2 = this.startNodeAt(startLoc);
-            
-            node2.qualification = node;
-            node2.id = this.flowParseRestrictedIdentifier(true);
-            node = this.finishNode(node2, 'QualifiedTypeIdentifier');
-        }
-        
-        return node;
-    }
-    
-    flowParseGenericType(startLoc, id) {
-        const node = this.startNodeAt(startLoc);
-        
-        node.typeParameters = null;
-        node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterInstantiation();
-        }
-        
-        return this.finishNode(node, 'GenericTypeAnnotation');
-    }
-    
-    flowParseTypeofType() {
-        const node = this.startNode();
-        this.expect(87);
-        node.argument = this.flowParsePrimaryType();
-        return this.finishNode(node, 'TypeofTypeAnnotation');
-    }
-    
-    flowParseTupleType() {
-        const node = this.startNode();
-        
-        node.types = [];
-        this.expect(0);
-        while (this.state.pos < this.length && !this.match(3)) {
-            node.types.push(this.flowParseType());
-            
-            if (this.match(3))
-                break;
-            
-            this.expect(12);
-        }
-        
-        this.expect(3);
-        return this.finishNode(node, 'TupleTypeAnnotation');
-    }
-    
-    flowParseFunctionTypeParam(first) {
-        let name = null;
-        let optional = false;
-        let typeAnnotation2 = null;
-        const node = this.startNode();
-        const lh = this.lookahead();
-        const isThis = this.state.type === 78;
-        
-        if (lh.type === 14 || lh.type === 17) {
-            if (isThis && !first) {
-                this.raise(FlowErrors.ThisParamMustBeFirst, node);
-            }
-            
-            name = this.parseIdentifier(isThis);
-            
-            if (this.eat(17)) {
-                optional = true;
-                
-                if (isThis) {
-                    this.raise(FlowErrors.ThisParamMayNotBeOptional, node);
-                }
-            }
-            
-            typeAnnotation2 = this.flowParseTypeInitialiser();
-        } else {
-            typeAnnotation2 = this.flowParseType();
-        }
-        
-        node.name = name;
-        node.optional = optional;
-        node.typeAnnotation = typeAnnotation2;
-        return this.finishNode(node, 'FunctionTypeParam');
-    }
-    
-    reinterpretTypeAsFunctionTypeParam(type) {
-        const node = this.startNodeAt(type.loc.start);
-        
-        node.name = null;
-        node.optional = false;
-        node.typeAnnotation = type;
-        return this.finishNode(node, 'FunctionTypeParam');
-    }
-    
-    flowParseFunctionTypeParams(params = []) {
-        let rest = null;
-        let _this = null;
-        
-        if (this.match(78)) {
-            _this = this.flowParseFunctionTypeParam(true);
-            _this.name = null;
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        while (!this.match(11) && !this.match(21)) {
-            params.push(this.flowParseFunctionTypeParam(false));
-            
-            if (!this.match(11)) {
-                this.expect(12);
-            }
-        }
-        
-        if (this.eat(21)) {
-            rest = this.flowParseFunctionTypeParam(false);
-        }
-        
-        return {
-            params,
-            rest,
-            _this,
-        };
-    }
-    
-    flowIdentToTypeAnnotation(startLoc, node, id) {
-        switch(id.name) {
-        case 'any':
-            return this.finishNode(node, 'AnyTypeAnnotation');
-        
-        case 'bool':        
-        case 'boolean':
-            return this.finishNode(node, 'BooleanTypeAnnotation');
-        
-        case 'mixed':
-            return this.finishNode(node, 'MixedTypeAnnotation');
-        
-        case 'empty':
-            return this.finishNode(node, 'EmptyTypeAnnotation');
-        
-        case 'number':
-            return this.finishNode(node, 'NumberTypeAnnotation');
-        
-        case 'string':
-            return this.finishNode(node, 'StringTypeAnnotation');
-        
-        case 'symbol':
-            return this.finishNode(node, 'SymbolTypeAnnotation');
-        
-        default:
-            this.checkNotUnderscore(id.name);
-            return this.flowParseGenericType(startLoc, id);
-        }
-    }
-    
-    flowParsePrimaryType() {
-        const startLoc = this.state.startLoc;
-        const node = this.startNode();
-        let tmp;
-        let type;
-        let isGroupedType = false;
-        const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-        
-        switch(this.state.type) {
-        case 5:
-            return this.flowParseObjectType({
-                allowStatic: false,
-                allowExact: false,
-                allowSpread: true,
-                allowProto: false,
-                allowInexact: true,
-            });
-        
-        case 6:
-            return this.flowParseObjectType({
-                allowStatic: false,
-                allowExact: true,
-                allowSpread: true,
-                allowProto: false,
-                allowInexact: false,
-            });
-        
-        case 0:
-            this.state.noAnonFunctionType = false;
-            type = this.flowParseTupleType();
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-            return type;
-        
-        case 47: {
-            const node2 = this.startNode();
-            
-            node2.typeParameters = this.flowParseTypeParameterDeclaration();
-            this.expect(10);
-            tmp = this.flowParseFunctionTypeParams();
-            node2.params = tmp.params;
-            node2.rest = tmp.rest;
-            node2.this = tmp._this;
-            this.expect(11);
-            this.expect(19);
-            node2.returnType = this.flowParseType();
-            return this.finishNode(node2, 'FunctionTypeAnnotation');
-        }
-        
-        case 10: {
-            const node2 = this.startNode();
-            this.next();
-            
-            if (!this.match(11) && !this.match(21)) {
-                if (tokenIsIdentifier(this.state.type) || this.match(78)) {
-                    const token = this.lookahead().type;
-                    isGroupedType = token !== 17 && token !== 14;
-                } else {
-                    isGroupedType = true;
-                }
-            }
-            
-            if (isGroupedType) {
-                this.state.noAnonFunctionType = false;
-                type = this.flowParseType();
-                this.state.noAnonFunctionType = oldNoAnonFunctionType;
-                
-                if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
-                    this.expect(11);
-                    return type;
-                } else {
-                    this.eat(12);
-                }
-            }
-            
-            if (type) {
-                tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
-            } else {
-                tmp = this.flowParseFunctionTypeParams();
-            }
-            
-            node2.params = tmp.params;
-            node2.rest = tmp.rest;
-            node2.this = tmp._this;
-            this.expect(11);
-            this.expect(19);
-            node2.returnType = this.flowParseType();
-            node2.typeParameters = null;
-            return this.finishNode(node2, 'FunctionTypeAnnotation');
-        }
-        
-        case 134:
-            return this.parseLiteral(this.state.value, 'StringLiteralTypeAnnotation');
-        
-        case 85:        
-        case 86:
-            node.value = this.match(85);
-            this.next();
-            return this.finishNode(node, 'BooleanLiteralTypeAnnotation');
-        
-        case 53:
-            if (this.state.value === '-') {
-                this.next();
-                
-                if (this.match(135)) {
-                    return this.parseLiteralAtNode(-this.state.value, 'NumberLiteralTypeAnnotation', node);
-                }
-                
-                if (this.match(136)) {
-                    return this.parseLiteralAtNode(-this.state.value, 'BigIntLiteralTypeAnnotation', node);
-                }
-                
-                throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
-            }
-            
-            this.unexpected();
-            return;
-        
-        case 135:
-            return this.parseLiteral(this.state.value, 'NumberLiteralTypeAnnotation');
-        
-        case 136:
-            return this.parseLiteral(this.state.value, 'BigIntLiteralTypeAnnotation');
-        
-        case 88:
-            this.next();
-            return this.finishNode(node, 'VoidTypeAnnotation');
-        
-        case 84:
-            this.next();
-            return this.finishNode(node, 'NullLiteralTypeAnnotation');
-        
-        case 78:
-            this.next();
-            return this.finishNode(node, 'ThisTypeAnnotation');
-        
-        case 55:
-            this.next();
-            return this.finishNode(node, 'ExistsTypeAnnotation');
-        
-        case 87:
-            return this.flowParseTypeofType();
-        
-        default:
-            if (tokenIsKeyword(this.state.type)) {
-                const label = tokenLabelName(this.state.type);
-                this.next();
-                return super.createIdentifier(node, label);
-            } else if (tokenIsIdentifier(this.state.type)) {
-                if (this.isContextual(129)) {
-                    return this.flowParseInterfaceType();
-                }
-                
-                return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
-            }
-        }
-        
-        this.unexpected();
-    }
-    
-    flowParsePostfixType() {
-        const startLoc = this.state.startLoc;
-        let type = this.flowParsePrimaryType();
-        let seenOptionalIndexedAccess = false;
-        
-        while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
-            const node = this.startNodeAt(startLoc);
-            const optional = this.eat(18);
-            
-            seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
-            this.expect(0);
-            
-            if (!optional && this.match(3)) {
-                node.elementType = type;
-                this.next();
-                type = this.finishNode(node, 'ArrayTypeAnnotation');
-            } else {
-                node.objectType = type;
-                node.indexType = this.flowParseType();
-                this.expect(3);
-                
-                if (seenOptionalIndexedAccess) {
-                    node.optional = optional;
-                    type = this.finishNode(node, 'OptionalIndexedAccessType');
-                } else {
-                    type = this.finishNode(node, 'IndexedAccessType');
-                }
-            }
-        }
-        
-        return type;
-    }
-    
-    flowParsePrefixType() {
-        const node = this.startNode();
-        
-        if (this.eat(17)) {
-            node.typeAnnotation = this.flowParsePrefixType();
-            return this.finishNode(node, 'NullableTypeAnnotation');
-        } else {
-            return this.flowParsePostfixType();
-        }
-    }
-    
-    flowParseAnonFunctionWithoutParens() {
-        const param = this.flowParsePrefixType();
-        
-        if (!this.state.noAnonFunctionType && this.eat(19)) {
-            const node = this.startNodeAt(param.loc.start);
-            
-            node.params = [
-                this.reinterpretTypeAsFunctionTypeParam(param),
-            ];
-            node.rest = null;
-            node.this = null;
-            node.returnType = this.flowParseType();
-            node.typeParameters = null;
-            return this.finishNode(node, 'FunctionTypeAnnotation');
-        }
-        
-        return param;
-    }
-    
-    flowParseIntersectionType() {
-        const node = this.startNode();
-        this.eat(45);
-        const type = this.flowParseAnonFunctionWithoutParens();
-        
-        node.types = [type];
-        while (this.eat(45)) {
-            node.types.push(this.flowParseAnonFunctionWithoutParens());
-        }
-        
-        return node.types.length === 1 ? type : this.finishNode(node, 'IntersectionTypeAnnotation');
-    }
-    
-    flowParseUnionType() {
-        const node = this.startNode();
-        this.eat(43);
-        const type = this.flowParseIntersectionType();
-        
-        node.types = [type];
-        while (this.eat(43)) {
-            node.types.push(this.flowParseIntersectionType());
-        }
-        
-        return node.types.length === 1 ? type : this.finishNode(node, 'UnionTypeAnnotation');
-    }
-    
-    flowParseType() {
-        const oldInType = this.state.inType;
-        
-        this.state.inType = true;
-        const type = this.flowParseUnionType();
-        
-        this.state.inType = oldInType;
-        return type;
-    }
-    
-    flowParseTypeOrImplicitInstantiation() {
-        if (this.state.type === 132 && this.state.value === '_') {
-            const startLoc = this.state.startLoc;
-            const node = this.parseIdentifier();
-            
-            return this.flowParseGenericType(startLoc, node);
-        } else {
-            return this.flowParseType();
-        }
-    }
-    
-    flowParseTypeAnnotation() {
-        const node = this.startNode();
-        
-        node.typeAnnotation = this.flowParseTypeInitialiser();
-        return this.finishNode(node, 'TypeAnnotation');
-    }
-    
-    flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
-        const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
-        
-        if (this.match(14)) {
-            ident.typeAnnotation = this.flowParseTypeAnnotation();
-            this.resetEndLocation(ident);
-        }
-        
-        return ident;
-    }
-    
-    typeCastToParameter(node) {
-        node.expression.typeAnnotation = node.typeAnnotation;
-        this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
-        return node.expression;
-    }
-    
-    flowParseVariance() {
-        let variance2 = null;
-        
-        if (this.match(53)) {
-            variance2 = this.startNode();
-            
-            if (this.state.value === '+') {
-                variance2.kind = 'plus';
-            } else {
-                variance2.kind = 'minus';
-            }
-            
-            this.next();
-            return this.finishNode(variance2, 'Variance');
-        }
-        
-        return variance2;
-    }
-    
-    parseFunctionBody(node, allowExpressionBody, isMethod3 = false) {
-        if (allowExpressionBody) {
-            this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod3));
-            return;
-        }
-        
-        super.parseFunctionBody(node, false, isMethod3);
-    }
-    
-    parseFunctionBodyAndFinish(node, type, isMethod3 = false) {
-        if (this.match(14)) {
-            const typeNode = this.startNode();
-            
-            [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-            node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, 'TypeAnnotation') : null;
-        }
-        
-        return super.parseFunctionBodyAndFinish(node, type, isMethod3);
-    }
-    
-    parseStatementLike(flags) {
-        if (this.state.strict && this.isContextual(129)) {
-            const lookahead = this.lookahead();
-            
-            if (tokenIsKeywordOrIdentifier(lookahead.type)) {
-                const node = this.startNode();
-                this.next();
-                return this.flowParseInterface(node);
-            }
-        } else if (this.isContextual(126)) {
-            const node = this.startNode();
-            this.next();
-            return this.flowParseEnumDeclaration(node);
-        }
-        
-        const stmt = super.parseStatementLike(flags);
-        
-        if (this.flowPragma === void 0 && !this.isValidDirective(stmt)) {
-            this.flowPragma = null;
-        }
-        
-        return stmt;
-    }
-    
-    parseExpressionStatement(node, expr, decorators) {
-        if (expr.type === 'Identifier') {
-            if (expr.name === 'declare') {
-                if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
-                    return this.flowParseDeclare(node);
-                }
-            } else if (tokenIsIdentifier(this.state.type)) {
-                if (expr.name === 'interface') {
-                    return this.flowParseInterface(node);
-                } else if (expr.name === 'type') {
-                    return this.flowParseTypeAlias(node);
-                } else if (expr.name === 'opaque') {
-                    return this.flowParseOpaqueType(node, false);
-                }
-
-            }
-        }
-        
-        return super.parseExpressionStatement(node, expr, decorators);
-    }
-    
-    shouldParseExportDeclaration() {
-        const {type} = this.state;
-        
-        if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
-            return !this.state.containsEsc;
-        }
-        
-        return super.shouldParseExportDeclaration();
-    }
-    
-    isExportDefaultSpecifier() {
-        const {type} = this.state;
-        
-        if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
-            return this.state.containsEsc;
-        }
-        
-        return super.isExportDefaultSpecifier();
-    }
-    
-    parseExportDefaultExpression() {
-        if (this.isContextual(126)) {
-            const node = this.startNode();
-            this.next();
-            return this.flowParseEnumDeclaration(node);
-        }
-        
-        return super.parseExportDefaultExpression();
-    }
-    
-    parseConditional(expr, startLoc, refExpressionErrors) {
-        if (!this.match(17))
-            return expr;
-        
-        if (this.state.maybeInArrowParameters) {
-            const nextCh = this.lookaheadCharCode();
-            
-            if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
-                this.setOptionalParametersError(refExpressionErrors);
-                return expr;
-            }
-        }
-        
-        this.expect(17);
-        const state = this.state.clone();
-        const originalNoArrowAt = this.state.noArrowAt;
-        const node = this.startNodeAt(startLoc);
-        
-        let {consequent, failed} = this.tryParseConditionalConsequent();
-        
-        let [valid, invalid] = this.getArrowLikeExpressions(consequent);
-        
-        if (failed || invalid.length > 0) {
-            const noArrowAt = [...originalNoArrowAt];
-            
-            if (invalid.length > 0) {
-                this.state = state;
-                this.state.noArrowAt = noArrowAt;
-                for (let i = 0; i < invalid.length; i++) {
-                    noArrowAt.push(invalid[i].start);
-                }
-                
-                ({
-                    consequent,
-                    failed,
-                } = this.tryParseConditionalConsequent());
-                [valid, invalid] = this.getArrowLikeExpressions(consequent);
-            }
-            
-            if (failed && valid.length > 1) {
-                this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
-            }
-            
-            if (failed && valid.length === 1) {
-                this.state = state;
-                noArrowAt.push(valid[0].start);
-                this.state.noArrowAt = noArrowAt;
-                ({
-                    consequent,
-                    failed,
-                } = this.tryParseConditionalConsequent());
-            }
-        }
-        
-        this.getArrowLikeExpressions(consequent, true);
-        this.state.noArrowAt = originalNoArrowAt;
-        this.expect(14);
-        node.test = expr;
-        node.consequent = consequent;
-        node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(void 0, void 0));
-        
-        return this.finishNode(node, 'ConditionalExpression');
-    }
-    
-    tryParseConditionalConsequent() {
-        this.state.noArrowParamsConversionAt.push(this.state.start);
-        const consequent = this.parseMaybeAssignAllowIn();
-        const failed = !this.match(14);
-        
-        this.state.noArrowParamsConversionAt.pop();
-        return {
-            consequent,
-            failed,
-        };
-    }
-    
-    getArrowLikeExpressions(node, disallowInvalid) {
-        const stack = [node];
-        const arrows = [];
-        
-        while (stack.length !== 0) {
-            const node2 = stack.pop();
-            
-            if (node2.type === 'ArrowFunctionExpression' && node2.body.type !== 'BlockStatement') {
-                if (node2.typeParameters || !node2.returnType) {
-                    this.finishArrowValidation(node2);
-                } else {
-                    arrows.push(node2);
-                }
-                
-                stack.push(node2.body);
-            } else if (node2.type === 'ConditionalExpression') {
-                stack.push(node2.consequent);
-                stack.push(node2.alternate);
-            }
-        }
-        
-        if (disallowInvalid) {
-            arrows.forEach((node2) => this.finishArrowValidation(node2));
-            return [
-                arrows,
-                [],
-            ];
-        }
-        
-        return partition(arrows, (node2) => node2.params.every((param) => this.isAssignable(param, true)));
-    }
-    
-    finishArrowValidation(node) {
-        this.toAssignableList(node.params, node.extra?.trailingCommaLoc, false);
-        this.scope.enter(514 | 4);
-        super.checkParams(node, false, true);
-        this.scope.exit();
-    }
-    
-    forwardNoArrowParamsConversionAt(node, parse3) {
-        let result;
-        
-        if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
-            this.state.noArrowParamsConversionAt.push(this.state.start);
-            result = parse3();
-            this.state.noArrowParamsConversionAt.pop();
-        } else {
-            result = parse3();
-        }
-        
-        return result;
-    }
-    
-    parseParenItem(node, startLoc) {
-        const newNode = super.parseParenItem(node, startLoc);
-        
-        if (this.eat(17)) {
-            newNode.optional = true;
-            this.resetEndLocation(node);
-        }
-        
-        if (this.match(14)) {
-            const typeCastNode = this.startNodeAt(startLoc);
-            
-            typeCastNode.expression = newNode;
-            typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
-            return this.finishNode(typeCastNode, 'TypeCastExpression');
-        }
-        
-        return newNode;
-    }
-    
-    assertModuleNodeAllowed(node) {
-        if (node.type === 'ImportDeclaration' && (node.importKind === 'type' || node.importKind === 'typeof') || node.type === 'ExportNamedDeclaration' && node.exportKind === 'type' || node.type === 'ExportAllDeclaration' && node.exportKind === 'type') {
-            return;
-        }
-        
-        super.assertModuleNodeAllowed(node);
-    }
-    
-    parseExportDeclaration(node) {
-        if (this.isContextual(130)) {
-            node.exportKind = 'type';
-            const declarationNode = this.startNode();
-            this.next();
-            
-            if (this.match(5)) {
-                node.specifiers = this.parseExportSpecifiers(true);
-                super.parseExportFrom(node);
-                return null;
-            } else {
-                return this.flowParseTypeAlias(declarationNode);
-            }
-        } else if (this.isContextual(131)) {
-            node.exportKind = 'type';
-            const declarationNode = this.startNode();
-            this.next();
-            return this.flowParseOpaqueType(declarationNode, false);
-        } else if (this.isContextual(129)) {
-            node.exportKind = 'type';
-            const declarationNode = this.startNode();
-            this.next();
-            return this.flowParseInterface(declarationNode);
-        } else if (this.isContextual(126)) {
-            node.exportKind = 'value';
-            const declarationNode = this.startNode();
-            this.next();
-            return this.flowParseEnumDeclaration(declarationNode);
-        } else {
-            return super.parseExportDeclaration(node);
-        }
-
-
-    }
-    
-    eatExportStar(node) {
-        if (super.eatExportStar(node))
-            return true;
-        
-        if (this.isContextual(130) && this.lookahead().type === 55) {
-            node.exportKind = 'type';
-            this.next();
-            this.next();
-            return true;
-        }
-        
-        return false;
-    }
-    
-    maybeParseExportNamespaceSpecifier(node) {
-        const {startLoc} = this.state;
-        
-        const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
-        
-        if (hasNamespace && node.exportKind === 'type') {
-            this.unexpected(startLoc);
-        }
-        
-        return hasNamespace;
-    }
-    
-    parseClassId(node, isStatement5, optionalId) {
-        super.parseClassId(node, isStatement5, optionalId);
-        
-        if (this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-    }
-    
-    parseClassMember(classBody2, member, state) {
-        const {startLoc} = this.state;
-        
-        if (this.isContextual(125)) {
-            if (super.parseClassMemberFromModifier(classBody2, member)) {
-                return;
-            }
-            
-            member.declare = true;
-        }
-        
-        super.parseClassMember(classBody2, member, state);
-        
-        if (member.declare) {
-            if (member.type !== 'ClassProperty' && member.type !== 'ClassPrivateProperty' && member.type !== 'PropertyDefinition') {
-                this.raise(FlowErrors.DeclareClassElement, startLoc);
-            } else if (member.value) {
-                this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);
-            }
-        }
-    }
-    
-    isIterator(word) {
-        return word === 'iterator' || word === 'asyncIterator';
-    }
-    
-    readIterator() {
-        const word = super.readWord1();
-        const fullWord = '@@' + word;
-        
-        if (!this.isIterator(word) || !this.state.inType) {
-            this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {
-                identifierName: fullWord,
-            });
-        }
-        
-        this.finishToken(132, fullWord);
-    }
-    
-    getTokenFromCode(code2) {
-        const next = this.input.charCodeAt(this.state.pos + 1);
-        
-        if (code2 === 123 && next === 124) {
-            this.finishOp(6, 2);
-        } else if (this.state.inType && (code2 === 62 || code2 === 60)) {
-            this.finishOp(code2 === 62 ? 48 : 47, 1);
-        } else if (this.state.inType && code2 === 63) {
-            if (next === 46) {
-                this.finishOp(18, 2);
-            } else {
-                this.finishOp(17, 1);
-            }
-        } else if (isIteratorStart(code2, next, this.input.charCodeAt(this.state.pos + 2))) {
-            this.state.pos += 2;
-            this.readIterator();
-        } else {
-            super.getTokenFromCode(code2);
-        }
-
-
-    }
-    
-    isAssignable(node, isBinding3) {
-        if (node.type === 'TypeCastExpression') {
-            return this.isAssignable(node.expression, isBinding3);
-        } else {
-            return super.isAssignable(node, isBinding3);
-        }
-    }
-    
-    toAssignable(node, isLHS = false) {
-        if (!isLHS && node.type === 'AssignmentExpression' && node.left.type === 'TypeCastExpression') {
-            node.left = this.typeCastToParameter(node.left);
-        }
-        
-        super.toAssignable(node, isLHS);
-    }
-    
-    toAssignableList(exprList, trailingCommaLoc, isLHS) {
-        for (let i = 0; i < exprList.length; i++) {
-            const expr = exprList[i];
-            
-            if (expr?.type === 'TypeCastExpression') {
-                exprList[i] = this.typeCastToParameter(expr);
-            }
-        }
-        
-        super.toAssignableList(exprList, trailingCommaLoc, isLHS);
-    }
-    
-    toReferencedList(exprList, isParenthesizedExpr) {
-        for (let i = 0; i < exprList.length; i++) {
-            const expr = exprList[i];
-            
-            if (expr && expr.type === 'TypeCastExpression' && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) {
-                this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
-            }
-        }
-        
-        return exprList;
-    }
-    
-    parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
-        const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
-        
-        if (canBePattern && !this.state.maybeInArrowParameters) {
-            this.toReferencedList(node.elements);
-        }
-        
-        return node;
-    }
-    
-    isValidLVal(type, isParenthesized, binding) {
-        return type === 'TypeCastExpression' || super.isValidLVal(type, isParenthesized, binding);
-    }
-    
-    parseClassProperty(node) {
-        if (this.match(14)) {
-            node.typeAnnotation = this.flowParseTypeAnnotation();
-        }
-        
-        return super.parseClassProperty(node);
-    }
-    
-    parseClassPrivateProperty(node) {
-        if (this.match(14)) {
-            node.typeAnnotation = this.flowParseTypeAnnotation();
-        }
-        
-        return super.parseClassPrivateProperty(node);
-    }
-    
-    isClassMethod() {
-        return this.match(47) || super.isClassMethod();
-    }
-    
-    isClassProperty() {
-        return this.match(14) || super.isClassProperty();
-    }
-    
-    isNonstaticConstructor(method) {
-        return !this.match(14) && super.isNonstaticConstructor(method);
-    }
-    
-    pushClassMethod(classBody2, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-        if (method.variance) {
-            this.unexpected(method.variance.loc.start);
-        }
-        
-        delete method.variance;
-        
-        if (this.match(47)) {
-            method.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        super.pushClassMethod(classBody2, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
-        
-        if (method.params && isConstructor) {
-            const params = method.params;
-            
-            if (params.length > 0 && this.isThisParam(params[0])) {
-                this.raise(FlowErrors.ThisParamBannedInConstructor, method);
-            }
-        } else if (method.type === 'MethodDefinition' && isConstructor && method.value.params) {
-            const params = method.value.params;
-            
-            if (params.length > 0 && this.isThisParam(params[0])) {
-                this.raise(FlowErrors.ThisParamBannedInConstructor, method);
-            }
-        }
-    }
-    
-    pushClassPrivateMethod(classBody2, method, isGenerator, isAsync) {
-        if (method.variance) {
-            this.unexpected(method.variance.loc.start);
-        }
-        
-        delete method.variance;
-        
-        if (this.match(47)) {
-            method.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        super.pushClassPrivateMethod(classBody2, method, isGenerator, isAsync);
-    }
-    
-    parseClassSuper(node) {
-        super.parseClassSuper(node);
-        
-        if (node.superClass && (this.match(47) || this.match(51))) {
-            {
-                node.superTypeArguments = this.flowParseTypeParameterInstantiationInExpression();
-            }
-        }
-        
-        if (this.isContextual(113)) {
-            this.next();
-            const implemented = node.implements = [];
-            
-            do {
-                const node2 = this.startNode();
-                
-                node2.id = this.flowParseRestrictedIdentifier(true);
-                
-                if (this.match(47)) {
-                    node2.typeParameters = this.flowParseTypeParameterInstantiation();
-                } else {
-                    node2.typeParameters = null;
-                }
-                
-                implemented.push(this.finishNode(node2, 'ClassImplements'));
-            } while (this.eat(12))
-        }
-    }
-    
-    checkGetterSetterParams(method) {
-        super.checkGetterSetterParams(method);
-        const params = this.getObjectOrClassMethodParams(method);
-        
-        if (params.length > 0) {
-            const param = params[0];
-            
-            if (this.isThisParam(param) && method.kind === 'get') {
-                this.raise(FlowErrors.GetterMayNotHaveThisParam, param);
-            } else if (this.isThisParam(param)) {
-                this.raise(FlowErrors.SetterMayNotHaveThisParam, param);
-            }
-        }
-    }
-    
-    parsePropertyNamePrefixOperator(node) {
-        node.variance = this.flowParseVariance();
-    }
-    
-    parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern3, isAccessor2, refExpressionErrors) {
-        if (prop.variance) {
-            this.unexpected(prop.variance.loc.start);
-        }
-        
-        delete prop.variance;
-        let typeParameters;
-        
-        if (this.match(47) && !isAccessor2) {
-            typeParameters = this.flowParseTypeParameterDeclaration();
-            
-            if (!this.match(10))
-                this.unexpected();
-        }
-        
-        const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern3, isAccessor2, refExpressionErrors);
-        
-        if (typeParameters) {
-            (result.value || result).typeParameters = typeParameters;
-        }
-        
-        return result;
-    }
-    
-    parseFunctionParamType(param) {
-        if (this.eat(17)) {
-            if (param.type !== 'Identifier') {
-                this.raise(FlowErrors.PatternIsOptional, param);
-            }
-            
-            if (this.isThisParam(param)) {
-                this.raise(FlowErrors.ThisParamMayNotBeOptional, param);
-            }
-            
-            param.optional = true;
-        }
-        
-        if (this.match(14)) {
-            param.typeAnnotation = this.flowParseTypeAnnotation();
-        } else if (this.isThisParam(param)) {
-            this.raise(FlowErrors.ThisParamAnnotationRequired, param);
-        }
-        
-        if (this.match(29) && this.isThisParam(param)) {
-            this.raise(FlowErrors.ThisParamNoDefault, param);
-        }
-        
-        this.resetEndLocation(param);
-        return param;
-    }
-    
-    parseMaybeDefault(startLoc, left) {
-        const node = super.parseMaybeDefault(startLoc, left);
-        
-        if (node.type === 'AssignmentPattern' && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-            this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);
-        }
-        
-        return node;
-    }
-    
-    checkImportReflection(node) {
-        super.checkImportReflection(node);
-        
-        if (node.module && node.importKind !== 'value') {
-            this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
-        }
-    }
-    
-    parseImportSpecifierLocal(node, specifier, type) {
-        specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
-        node.specifiers.push(this.finishImportSpecifier(specifier, type));
-    }
-    
-    isPotentialImportPhase(isExport) {
-        if (super.isPotentialImportPhase(isExport))
-            return true;
-        
-        if (this.isContextual(130)) {
-            if (!isExport)
-                return true;
-            
-            const ch = this.lookaheadCharCode();
-            
-            return ch === 123 || ch === 42;
-        }
-        
-        return !isExport && this.isContextual(87);
-    }
-    
-    applyImportPhase(node, isExport, phase, loc) {
-        super.applyImportPhase(node, isExport, phase, loc);
-        
-        if (isExport) {
-            if (!phase && this.match(65)) {
-                return;
-            }
-            
-            node.exportKind = phase === 'type' ? phase : 'value';
-        } else {
-            if (phase === 'type' && this.match(55))
-                this.unexpected();
-            
-            node.importKind = phase === 'type' || phase === 'typeof' ? phase : 'value';
-        }
-    }
-    
-    parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
-        const firstIdent = specifier.imported;
-        let specifierTypeKind = null;
-        
-        if (firstIdent.type === 'Identifier') {
-            if (firstIdent.name === 'type') {
-                specifierTypeKind = 'type';
-            } else if (firstIdent.name === 'typeof') {
-                specifierTypeKind = 'typeof';
-            }
-        }
-        
-        let isBinding3 = false;
-        
-        if (this.isContextual(93) && !this.isLookaheadContextual('as')) {
-            const as_ident = this.parseIdentifier(true);
-            
-            if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
-                specifier.imported = as_ident;
-                specifier.importKind = specifierTypeKind;
-                specifier.local = this.cloneIdentifier(as_ident);
-            } else {
-                specifier.imported = firstIdent;
-                specifier.importKind = null;
-                specifier.local = this.parseIdentifier();
-            }
-        } else {
-            if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
-                specifier.imported = this.parseIdentifier(true);
-                specifier.importKind = specifierTypeKind;
-            } else {
-                if (importedIsString) {
-                    throw this.raise(Errors.ImportBindingIsString, specifier, {
-                        importName: firstIdent.value,
-                    });
-                }
-                
-                specifier.imported = firstIdent;
-                specifier.importKind = null;
-            }
-            
-            if (this.eatContextual(93)) {
-                specifier.local = this.parseIdentifier();
-            } else {
-                isBinding3 = true;
-                specifier.local = this.cloneIdentifier(specifier.imported);
-            }
-        }
-        
-        const specifierIsTypeImport = hasTypeImportKind(specifier);
-        
-        if (isInTypeOnlyImport && specifierIsTypeImport) {
-            this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
-        }
-        
-        if (isInTypeOnlyImport || specifierIsTypeImport) {
-            this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
-        }
-        
-        if (isBinding3 && !isInTypeOnlyImport && !specifierIsTypeImport) {
-            this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
-        }
-        
-        return this.finishImportSpecifier(specifier, 'ImportSpecifier');
-    }
-    
-    parseBindingAtom() {
-        switch(this.state.type) {
-        case 78:
-            return this.parseIdentifier(true);
-        
-        default:
-            return super.parseBindingAtom();
-        }
-    }
-    
-    parseFunctionParams(node, isConstructor) {
-        const kind = node.kind;
-        
-        if (kind !== 'get' && kind !== 'set' && this.match(47)) {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-        }
-        
-        super.parseFunctionParams(node, isConstructor);
-    }
-    
-    parseVarId(decl, kind) {
-        super.parseVarId(decl, kind);
-        
-        if (this.match(14)) {
-            decl.id.typeAnnotation = this.flowParseTypeAnnotation();
-            this.resetEndLocation(decl.id);
-        }
-    }
-    
-    parseAsyncArrowFromCallExpression(node, call2) {
-        if (this.match(14)) {
-            const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-            
-            this.state.noAnonFunctionType = true;
-            node.returnType = this.flowParseTypeAnnotation();
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-        }
-        
-        return super.parseAsyncArrowFromCallExpression(node, call2);
-    }
-    
-    shouldParseAsyncArrow() {
-        return this.match(14) || super.shouldParseAsyncArrow();
-    }
-    
-    parseMaybeAssign(refExpressionErrors, afterLeftParse) {
-        let state = null;
-        let jsx2;
-        
-        if (this.hasPlugin('jsx') && (this.match(143) || this.match(47))) {
-            state = this.state.clone();
-            jsx2 = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
-            
-            if (!jsx2.error)
-                return jsx2.node;
-            
-            const {context} = this.state;
-            
-            const currentContext = context[context.length - 1];
-            
-            if (currentContext === types.j_oTag || currentContext === types.j_expr) {
-                context.pop();
-            }
-        }
-        
-        if (jsx2?.error || this.match(47)) {
-            state = state || this.state.clone();
-            let typeParameters;
-            const arrow = this.tryParse((abort) => {
-                typeParameters = this.flowParseTypeParameterDeclaration();
-                const arrowExpression2 = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
-                    const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
-                    this.resetStartLocationFromNode(result, typeParameters);
-                    return result;
-                });
-                
-                if (arrowExpression2.extra?.parenthesized)
-                    abort();
-                
-                const expr = this.maybeUnwrapTypeCastExpression(arrowExpression2);
-                
-                if (expr.type !== 'ArrowFunctionExpression')
-                    abort();
-                
-                expr.typeParameters = typeParameters;
-                this.resetStartLocationFromNode(expr, typeParameters);
-                return arrowExpression2;
-            }, state);
-            
-            let arrowExpression = null;
-            
-            if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === 'ArrowFunctionExpression') {
-                if (!arrow.error && !arrow.aborted) {
-                    if (arrow.node.async) {
-                        this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
-                    }
-                    
-                    return arrow.node;
-                }
-                
-                arrowExpression = arrow.node;
-            }
-            
-            if (jsx2?.node) {
-                this.state = jsx2.failState;
-                return jsx2.node;
-            }
-            
-            if (arrowExpression) {
-                this.state = arrow.failState;
-                return arrowExpression;
-            }
-            
-            if (jsx2?.thrown)
-                throw jsx2.error;
-            
-            if (arrow.thrown)
-                throw arrow.error;
-            
-            throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
-        }
-        
-        return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
-    }
-    
-    parseArrow(node) {
-        if (this.match(14)) {
-            const result = this.tryParse(() => {
-                const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-                
-                this.state.noAnonFunctionType = true;
-                const typeNode = this.startNode();
-                
-                [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-                this.state.noAnonFunctionType = oldNoAnonFunctionType;
-                
-                if (this.canInsertSemicolon())
-                    this.unexpected();
-                
-                if (!this.match(19))
-                    this.unexpected();
-                
-                return typeNode;
-            });
-            
-            if (result.thrown)
-                return null;
-            
-            if (result.error)
-                this.state = result.failState;
-            
-            node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, 'TypeAnnotation') : null;
-        }
-        
-        return super.parseArrow(node);
-    }
-    
-    shouldParseArrow(params) {
-        return this.match(14) || super.shouldParseArrow(params);
-    }
-    
-    setArrowFunctionParameters(node, params) {
-        if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
-            node.params = params;
-        } else {
-            super.setArrowFunctionParameters(node, params);
-        }
-    }
-    
-    checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
-        if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
-            return;
-        }
-        
-        for (let i = 0; i < node.params.length; i++) {
-            if (this.isThisParam(node.params[i]) && i > 0) {
-                this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);
-            }
-        }
-        
-        super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
+    'false',
+    'in',
+    'instanceof',
+    'typeof',
+    'void',
+    'delete',
+    'implements',
+    'interface',
+    'let',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    'yield',
+    'eval',
+    'arguments',
+    'enum',
+    'await',
+]);
+
+function canBeReservedWord(word) {
+    return reservedWordLikeSet.has(word);
+}
+
+var Scope = class {
+    constructor(flags) {
+        __publicField(this, 'flags', 0);
+        __publicField(this, 'names',         /* @__PURE__ */new Map());
+        __publicField(this, 'firstLexicalName', '');
+        this.flags = flags;
     }
-    
-    parseParenAndDistinguishExpression(canBeArrow) {
-        return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
+};
+
+var ScopeHandler = class {
+    constructor(parser, inModule) {
+        __publicField(this, 'parser');
+        __publicField(this, 'scopeStack', []);
+        __publicField(this, 'inModule');
+        __publicField(this, 'undefinedExports',         /* @__PURE__ */new Map());
+        this.parser = parser;
+        this.inModule = inModule;
     }
     
-    parseSubscripts(base, startLoc, noCalls) {
-        if (base.type === 'Identifier' && base.name === 'async' && this.state.noArrowAt.includes(startLoc.index)) {
-            this.next();
-            const node = this.startNodeAt(startLoc);
-            
-            node.callee = base;
-            node.arguments = super.parseCallExpressionArguments();
-            base = this.finishNode(node, 'CallExpression');
-        } else if (base.type === 'Identifier' && base.name === 'async' && this.match(47)) {
-            const state = this.state.clone();
-            const arrow = this.tryParse((abort) => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);
-            
-            if (!arrow.error && !arrow.aborted)
-                return arrow.node;
-            
-            const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);
-            
-            if (result.node && !result.error)
-                return result.node;
-            
-            if (arrow.node) {
-                this.state = arrow.failState;
-                return arrow.node;
-            }
-            
-            if (result.node) {
-                this.state = result.failState;
-                return result.node;
-            }
-            
-            throw arrow.error || result.error;
-        }
-        
-        return super.parseSubscripts(base, startLoc, noCalls);
+    get inTopLevel() {
+        return (this.currentScope().flags & 1) > 0;
     }
     
-    parseSubscript(base, startLoc, noCalls, subscriptState) {
-        if (this.match(18) && this.isLookaheadToken_lt()) {
-            subscriptState.optionalChainMember = true;
-            
-            if (noCalls) {
-                subscriptState.stop = true;
-                return base;
-            }
-            
-            this.next();
-            const node = this.startNodeAt(startLoc);
-            
-            node.callee = base;
-            node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
-            this.expect(10);
-            node.arguments = this.parseCallExpressionArguments();
-            node.optional = true;
-            return this.finishCallExpression(node, true);
-        } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
-            const node = this.startNodeAt(startLoc);
-            
-            node.callee = base;
-            const result = this.tryParse(() => {
-                node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
-                this.expect(10);
-                node.arguments = super.parseCallExpressionArguments();
-                
-                if (subscriptState.optionalChainMember) {
-                    node.optional = false;
-                }
-                
-                return this.finishCallExpression(node, subscriptState.optionalChainMember);
-            });
-            
-            if (result.node) {
-                if (result.error)
-                    this.state = result.failState;
-                
-                return result.node;
-            }
-        }
-        
-        return super.parseSubscript(base, startLoc, noCalls, subscriptState);
+    get inFunction() {
+        return (this.currentVarScopeFlags() & 2) > 0;
     }
     
-    parseNewCallee(node) {
-        super.parseNewCallee(node);
-        let targs = null;
-        
-        if (this.shouldParseTypes() && this.match(47)) {
-            targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
-        }
-        
-        node.typeArguments = targs;
+    get allowSuper() {
+        return (this.currentThisScopeFlags() & 16) > 0;
     }
     
-    parseAsyncArrowWithTypeParameters(startLoc) {
-        const node = this.startNodeAt(startLoc);
-        this.parseFunctionParams(node, false);
-        
-        if (!this.parseArrow(node))
-            return;
-        
-        return super.parseArrowExpression(node, void 0, true);
+    get allowDirectSuper() {
+        return (this.currentThisScopeFlags() & 32) > 0;
     }
     
-    readToken_mult_modulo(code2) {
-        const next = this.input.charCodeAt(this.state.pos + 1);
-        
-        if (code2 === 42 && next === 47 && this.state.hasFlowComment) {
-            this.state.hasFlowComment = false;
-            this.state.pos += 2;
-            this.nextToken();
-            return;
-        }
-        
-        super.readToken_mult_modulo(code2);
+    get allowNewTarget() {
+        return (this.currentThisScopeFlags() & 512) > 0;
     }
     
-    readToken_pipe_amp(code2) {
-        const next = this.input.charCodeAt(this.state.pos + 1);
-        
-        if (code2 === 124 && next === 125) {
-            this.finishOp(9, 2);
-            return;
-        }
-        
-        super.readToken_pipe_amp(code2);
+    get inClass() {
+        return (this.currentThisScopeFlags() & 64) > 0;
     }
     
-    parseTopLevel(file2, program3) {
-        const fileNode = super.parseTopLevel(file2, program3);
-        
-        if (this.state.hasFlowComment) {
-            this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());
-        }
-        
-        return fileNode;
+    get inClassAndNotInNonArrowFunction() {
+        const flags = this.currentThisScopeFlags();
+        return (flags & 64) > 0 && (flags & 2) === 0;
     }
     
-    skipBlockComment() {
-        if (this.hasPlugin('flowComments') && this.skipFlowComment()) {
-            if (this.state.hasFlowComment) {
-                throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);
-            }
-            
-            this.hasFlowCommentCompletion();
-            const commentSkip = this.skipFlowComment();
+    get inStaticBlock() {
+        for (let i = this.scopeStack.length - 1;; i--) {
+            const {flags} = this.scopeStack[i];
             
-            if (commentSkip) {
-                this.state.pos += commentSkip;
-                this.state.hasFlowComment = true;
+            if (flags & 128) {
+                return true;
             }
             
-            return;
-        }
-        
-        return super.skipBlockComment(this.state.hasFlowComment ? '*-/' : '*/');
-    }
-    
-    skipFlowComment() {
-        const {pos} = this.state;
-        
-        let shiftToFirstNonWhiteSpace = 2;
-        
-        while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
-            shiftToFirstNonWhiteSpace++;
-        }
-        
-        const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
-        const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
-        
-        if (ch2 === 58 && ch3 === 58) {
-            return shiftToFirstNonWhiteSpace + 2;
-        }
-        
-        if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === 'flow-include') {
-            return shiftToFirstNonWhiteSpace + 12;
-        }
-        
-        if (ch2 === 58 && ch3 !== 58) {
-            return shiftToFirstNonWhiteSpace;
-        }
-        
-        return false;
-    }
-    
-    hasFlowCommentCompletion() {
-        const end = this.input.indexOf('*/', this.state.pos);
-        
-        if (end === -1) {
-            throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
+            if (flags & (1667 | 64)) {
+                return false;
+            }
         }
     }
     
-    flowEnumErrorBooleanMemberNotInitialized(loc, {enumName, memberName}) {
-        this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {
-            memberName,
-            enumName,
-        });
+    get inNonArrowFunction() {
+        return (this.currentThisScopeFlags() & 2) > 0;
     }
     
-    flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
-        return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === 'symbol' ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
+    get inBareCaseStatement() {
+        return (this.currentScope().flags & 256) > 0;
     }
     
-    flowEnumErrorNumberMemberNotInitialized(loc, details) {
-        this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);
+    get treatFunctionsAsVar() {
+        return this.treatFunctionsAsVarInScope(this.currentScope());
     }
     
-    flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {
-        this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);
+    createScope(flags) {
+        return new Scope(flags);
     }
     
-    flowEnumMemberInit() {
-        const startLoc = this.state.startLoc;
-        const endOfInit = () => this.match(12) || this.match(8);
-        
-        switch(this.state.type) {
-        case 135: {
-            const literal = this.parseNumericLiteral(this.state.value);
-            
-            if (endOfInit()) {
-                return {
-                    type: 'number',
-                    loc: literal.loc.start,
-                    value: literal,
-                };
-            }
-            
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-        
-        case 134: {
-            const literal = this.parseStringLiteral(this.state.value);
-            
-            if (endOfInit()) {
-                return {
-                    type: 'string',
-                    loc: literal.loc.start,
-                    value: literal,
-                };
-            }
-            
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-        
-        case 85:        
-        case 86: {
-            const literal = this.parseBooleanLiteral(this.match(85));
-            
-            if (endOfInit()) {
-                return {
-                    type: 'boolean',
-                    loc: literal.loc.start,
-                    value: literal,
-                };
-            }
-            
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
-        
-        default:
-            return {
-                type: 'invalid',
-                loc: startLoc,
-            };
-        }
+    enter(flags) {
+        this.scopeStack.push(this.createScope(flags));
     }
     
-    flowEnumMemberRaw() {
-        const loc = this.state.startLoc;
-        const id = this.parseIdentifier(true);
-        const init = this.eat(29) ? this.flowEnumMemberInit() : {
-            type: 'none',
-            loc,
-        };
-        
-        return {
-            id,
-            init,
-        };
+    exit() {
+        const scope2 = this.scopeStack.pop();
+        return scope2.flags;
     }
     
-    flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
-        const {explicitType} = context;
-        
-        if (explicitType === null) {
-            return;
-        }
-        
-        if (explicitType !== expectedType) {
-            this.flowEnumErrorInvalidMemberInitializer(loc, context);
-        }
+    treatFunctionsAsVarInScope(scope2) {
+        return !!(scope2.flags & (2 | 128) || !this.parser.inModule && scope2.flags & 1);
     }
     
-    flowEnumMembers({enumName, explicitType}) {
-        const seenNames =         /* @__PURE__ */new Set();
-        const members = {
-            booleanMembers: [],
-            numberMembers: [],
-            stringMembers: [],
-            defaultedMembers: [],
-        };
-        
-        let hasUnknownMembers = false;
+    declareName(name, bindingType, loc) {
+        let scope2 = this.currentScope();
         
-        while (!this.match(8)) {
-            if (this.eat(21)) {
-                hasUnknownMembers = true;
-                break;
-            }
-            
-            const memberNode = this.startNode();
-            const {id, init} = this.flowEnumMemberRaw();
-            
-            const memberName = id.name;
-            
-            if (memberName === '') {
-                continue;
-            }
-            
-            if (/^[a-z]/.test(memberName)) {
-                this.raise(FlowErrors.EnumInvalidMemberName, id, {
-                    memberName,
-                    suggestion: memberName[0].toUpperCase() + memberName.slice(1),
-                    enumName,
-                });
-            }
-            
-            if (seenNames.has(memberName)) {
-                this.raise(FlowErrors.EnumDuplicateMemberName, id, {
-                    memberName,
-                    enumName,
-                });
-            }
-            
-            seenNames.add(memberName);
-            const context = {
-                enumName,
-                explicitType,
-                memberName,
-            };
-            
-            memberNode.id = id;
-            switch(init.type) {
-            case 'boolean': {
-                this.flowEnumCheckExplicitTypeMismatch(init.loc, context, 'boolean');
-                memberNode.init = init.value;
-                members.booleanMembers.push(this.finishNode(memberNode, 'EnumBooleanMember'));
-                break;
-            }
+        if (bindingType & 8 || bindingType & 16) {
+            this.checkRedeclarationInScope(scope2, name, bindingType, loc);
+            let type = scope2.names.get(name) || 0;
             
-            case 'number': {
-                this.flowEnumCheckExplicitTypeMismatch(init.loc, context, 'number');
-                memberNode.init = init.value;
-                members.numberMembers.push(this.finishNode(memberNode, 'EnumNumberMember'));
-                break;
+            if (bindingType & 16) {
+                type = type | 4;
+            } else {
+                if (!scope2.firstLexicalName) {
+                    scope2.firstLexicalName = name;
+                }
+                
+                type = type | 2;
             }
             
-            case 'string': {
-                this.flowEnumCheckExplicitTypeMismatch(init.loc, context, 'string');
-                memberNode.init = init.value;
-                members.stringMembers.push(this.finishNode(memberNode, 'EnumStringMember'));
-                break;
-            }
+            scope2.names.set(name, type);
             
-            case 'invalid': {
-                throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
+            if (bindingType & 8) {
+                this.maybeExportDefined(scope2, name);
             }
-            
-            case 'none': {
-                switch(explicitType) {
-                case 'boolean':
-                    this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
-                    break;
+        } else if (bindingType & 4) {
+            for (let i = this.scopeStack.length - 1; i >= 0; --i) {
+                scope2 = this.scopeStack[i];
+                this.checkRedeclarationInScope(scope2, name, bindingType, loc);
+                scope2.names.set(name, (scope2.names.get(name) || 0) | 1);
+                this.maybeExportDefined(scope2, name);
                 
-                case 'number':
-                    this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
+                if (scope2.flags & 1667)
                     break;
-                
-                default:
-                    members.defaultedMembers.push(this.finishNode(memberNode, 'EnumDefaultedMember'));
-                }
-            }
-            }
-            
-            if (!this.match(8)) {
-                this.expect(12);
             }
         }
         
-        return {
-            members,
-            hasUnknownMembers,
-        };
+        if (this.parser.inModule && scope2.flags & 1) {
+            this.undefinedExports.delete(name);
+        }
     }
     
-    flowEnumStringMembers(initializedMembers, defaultedMembers, {enumName}) {
-        if (initializedMembers.length === 0) {
-            return defaultedMembers;
-        } else if (defaultedMembers.length === 0) {
-            return initializedMembers;
-        } else if (defaultedMembers.length > initializedMembers.length) {
-            for (const member of initializedMembers) {
-                this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
-                    enumName,
-                });
-            }
-            
-            return defaultedMembers;
-        } else {
-            for (const member of defaultedMembers) {
-                this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
-                    enumName,
-                });
-            }
-            
-            return initializedMembers;
+    maybeExportDefined(scope2, name) {
+        if (this.parser.inModule && scope2.flags & 1) {
+            this.undefinedExports.delete(name);
         }
-
     }
     
-    flowEnumParseExplicitType({enumName}) {
-        if (!this.eatContextual(102))
-            return null;
-        
-        if (!tokenIsIdentifier(this.state.type)) {
-            throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, {
-                enumName,
+    checkRedeclarationInScope(scope2, name, bindingType, loc) {
+        if (this.isRedeclaredInScope(scope2, name, bindingType)) {
+            this.parser.raise(Errors.VarRedeclaration, loc, {
+                identifierName: name,
             });
         }
+    }
+    
+    isRedeclaredInScope(scope2, name, bindingType) {
+        if (!(bindingType & 1))
+            return false;
         
-        const {value} = this.state;
+        if (bindingType & 8) {
+            return scope2.names.has(name);
+        }
         
-        this.next();
+        const type = scope2.names.get(name);
         
-        if (value !== 'boolean' && value !== 'number' && value !== 'string' && value !== 'symbol') {
-            this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
-                enumName,
-                invalidEnumType: value,
-            });
+        if (bindingType & 16) {
+            return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope2) && (type & 1) > 0;
         }
         
-        return value;
+        return (type & 2) > 0 && !(scope2.flags & 8 && scope2.firstLexicalName === name)
+            || !this.treatFunctionsAsVarInScope(scope2) && (type & 4) > 0;
     }
     
-    flowEnumBody(node, id) {
-        const enumName = id.name;
-        const nameLoc = id.loc.start;
-        const explicitType = this.flowEnumParseExplicitType({
-            enumName,
-        });
-        
-        this.expect(5);
-        const {
-            members,
-            hasUnknownMembers,
-        } = this.flowEnumMembers({
-            enumName,
-            explicitType,
-        });
-        
-        node.hasUnknownMembers = hasUnknownMembers;
-        switch(explicitType) {
-        case 'boolean':
-            node.explicitType = true;
-            node.members = members.booleanMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumBooleanBody');
-        
-        case 'number':
-            node.explicitType = true;
-            node.members = members.numberMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumNumberBody');
-        
-        case 'string':
-            node.explicitType = true;
-            node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-                enumName,
-            });
-            this.expect(8);
-            return this.finishNode(node, 'EnumStringBody');
+    checkLocalExport(id) {
+        const {name} = id;
         
-        case 'symbol':
-            node.members = members.defaultedMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumSymbolBody');
+        const topLevelScope = this.scopeStack[0];
         
-        default: {
-            const empty = () => {
-                node.members = [];
-                this.expect(8);
-                return this.finishNode(node, 'EnumStringBody');
-            };
-            
-            node.explicitType = false;
-            const boolsLen = members.booleanMembers.length;
-            const numsLen = members.numberMembers.length;
-            const strsLen = members.stringMembers.length;
-            const defaultedLen = members.defaultedMembers.length;
-            
-            if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
-                return empty();
-            } else if (!boolsLen && !numsLen) {
-                node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-                    enumName,
-                });
-                this.expect(8);
-                return this.finishNode(node, 'EnumStringBody');
-            } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
-                for (const member of members.defaultedMembers) {
-                    this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
-                        enumName,
-                        memberName: member.id.name,
-                    });
-                }
-                
-                node.members = members.booleanMembers;
-                this.expect(8);
-                
-                return this.finishNode(node, 'EnumBooleanBody');
-            } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
-                for (const member of members.defaultedMembers) {
-                    this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
-                        enumName,
-                        memberName: member.id.name,
-                    });
-                }
-                
-                node.members = members.numberMembers;
-                this.expect(8);
-                
-                return this.finishNode(node, 'EnumNumberBody');
-            } else {
-                this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {
-                    enumName,
-                });
-                return empty();
-            }
-
-
-        }
+        if (!topLevelScope.names.has(name)) {
+            this.undefinedExports.set(name, id.loc.start);
         }
     }
     
-    flowParseEnumDeclaration(node) {
-        const id = this.parseIdentifier();
-        
-        node.id = id;
-        node.body = this.flowEnumBody(this.startNode(), id);
-        return this.finishNode(node, 'EnumDeclaration');
+    currentScope() {
+        return this.scopeStack[this.scopeStack.length - 1];
     }
     
-    jsxParseOpeningElementAfterName(node) {
-        if (this.shouldParseTypes()) {
-            if (this.match(47) || this.match(51)) {
-                node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
+    currentVarScopeFlags() {
+        for (let i = this.scopeStack.length - 1;; i--) {
+            const {flags} = this.scopeStack[i];
+            
+            if (flags & 1667) {
+                return flags;
             }
         }
-        
-        return super.jsxParseOpeningElementAfterName(node);
     }
     
-    isLookaheadToken_lt() {
-        const next = this.nextTokenStart();
-        
-        if (this.input.charCodeAt(next) === 60) {
-            const afterNext = this.input.charCodeAt(next + 1);
-            return afterNext !== 60 && afterNext !== 61;
+    currentThisScopeFlags() {
+        for (let i = this.scopeStack.length - 1;; i--) {
+            const {flags} = this.scopeStack[i];
+            
+            if (flags & (1667 | 64) && !(flags & 4)) {
+                return flags;
+            }
         }
-        
-        return false;
+    }
+};
+
+var FlowScope = class extends Scope {
+    constructor() {
+        super(...arguments);
+        __publicField(this, 'declareFunctions',         /* @__PURE__ */new Set());
+    }
+};
+
+var FlowScopeHandler = class extends ScopeHandler {
+    createScope(flags) {
+        return new FlowScope(flags);
     }
     
-    reScan_lt_gt() {
-        const {type} = this.state;
+    declareName(name, bindingType, loc) {
+        const scope2 = this.currentScope();
         
-        if (type === 47) {
-            this.state.pos -= 1;
-            this.readToken_lt();
-        } else if (type === 48) {
-            this.state.pos -= 1;
-            this.readToken_gt();
+        if (bindingType & 2048) {
+            this.checkRedeclarationInScope(scope2, name, bindingType, loc);
+            this.maybeExportDefined(scope2, name);
+            scope2.declareFunctions.add(name);
+            return;
         }
+        
+        super.declareName(name, bindingType, loc);
     }
     
-    reScan_lt() {
-        const {type} = this.state;
+    isRedeclaredInScope(scope2, name, bindingType) {
+        if (super.isRedeclaredInScope(scope2, name, bindingType))
+            return true;
         
-        if (type === 51) {
-            this.state.pos -= 2;
-            this.finishOp(47, 1);
-            return 47;
+        if (bindingType & 2048 && !scope2.declareFunctions.has(name)) {
+            const type = scope2.names.get(name);
+            return (type & 4) > 0 || (type & 2) > 0;
         }
         
-        return type;
+        return false;
     }
     
-    maybeUnwrapTypeCastExpression(node) {
-        return node.type === 'TypeCastExpression' ? node.expression : node;
+    checkLocalExport(id) {
+        if (!this.scopeStack[0].declareFunctions.has(id.name)) {
+            super.checkLocalExport(id);
+        }
     }
 };
 
+var reservedTypes = /* @__PURE__ */new Set([
+    '_',
+    'any',
+    'bool',
+    'boolean',
+    'empty',
+    'extends',
+    'false',
+    'interface',
+    'mixed',
+    'null',
+    'number',
+    'static',
+    'string',
+    'true',
+    'typeof',
+    'void',
+]);
+
+function isEsModuleType(bodyElement) {
+    return bodyElement.type === 'DeclareExportAllDeclaration'
+        || bodyElement.type === 'DeclareExportDeclaration'
+        && (!bodyElement.declaration
+        || bodyElement.declaration.type !== 'TypeAlias'
+        && bodyElement.declaration.type !== 'InterfaceDeclaration');
+}
+
+function hasTypeImportKind(node) {
+    return node.importKind === 'type' || node.importKind === 'typeof';
+}
+
+var exportSuggestions = {
+    const: 'declare export var',
+    let: 'declare export var',
+    type: 'export type',
+    interface: 'export interface',
+};
+
+function partition(list, test) {
+    const list1 = [];
+    const list2 = [];
+    
+    for (let i = 0; i < list.length; i++) {
+        (test(list[i], i, list) ? list1 : list2).push(list[i]);
+    }
+    
+    return [list1, list2];
+}
+
+var FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
+
 var entities = {
     __proto__: null,
     quot: '"',
@@ -30128,6 +27004,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         node.properties = [
             this.finishObjectProperty(withProperty),
         ];
+        this.eat(12);
         this.expect(8);
         return this.finishNode(node, 'ObjectExpression');
     }
@@ -31839,6 +28716,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                     const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
                     
                     if (asyncArrowFn) {
+                        state.stop = true;
                         return asyncArrowFn;
                     }
                 }
@@ -33189,6 +30067,11 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             node.extends ?? (node.extends = []);
             return;
         
+        case 'TSMappedType':
+            node.optional ?? (node.optional = false);
+            node.readonly ?? (node.readonly = void 0);
+            return;
+        
         case 'TSModuleDeclaration':
             node.declare ?? (node.declare = false);
             node.global ?? (node.global = node.kind === 'global');
@@ -33692,7 +30575,6 @@ function validatePlugins(pluginsMap) {
 var mixinPlugins = {
     estree,
     jsx,
-    flow,
     typescript,
     v8intrinsic,
     placeholders,
@@ -39076,8 +35958,7 @@ function populatePlaceholders(metadata, replacements) {
             });
     }
     
-    metadata
-        .placeholders
+    metadata.placeholders
         .slice()
         .reverse()
         .forEach((placeholder2) => {
@@ -39349,8 +36230,7 @@ function extendedTrace(fn) {
         throw new Error();
     } catch(error) {
         if (error.stack) {
-            rootStack = error
-                .stack
+            rootStack = error.stack
                 .split('\n')
                 .slice(3)
                 .join('\n');
@@ -41973,10 +38853,6 @@ function NewExpression2(node, parent) {
     
     this.print(node.typeArguments);
     
-    if (node.optional) {
-        this.token('?.');
-    }
-    
     if (node.arguments.length === 0 && this.tokenMap && !this.tokenMap.endMatches(node, ')')) {
         return;
     }
@@ -46560,7 +43436,7 @@ function normalizeOptions(code2, opts, ast) {
         }
         
         if (!Array.isArray(ast.tokens)) {
-            throw new Error('`experimental_preserveFormat` requires the AST to have attatched the token of the input code. Make sure to enable the `tokens: true` parser option.');
+            throw new Error('`experimental_preserveFormat` requires the AST to have attached the token of the input code. Make sure to enable the `tokens: true` parser option.');
         }
     }
     
@@ -46634,8 +43510,78 @@ function generate(ast, opts = {}, code2) {
 
 // node_modules/@babel/traverse/lib/index.js
 var import_debug = __toESM(require_src(), 1);
-var import_module = require('module');
-var import_meta = {};
+
+// node_modules/@babel/helper-globals/data/builtin-lower.json
+var builtin_lower_default = [
+    'decodeURI',
+    'decodeURIComponent',
+    'encodeURI',
+    'encodeURIComponent',
+    'escape',
+    'eval',
+    'globalThis',
+    'isFinite',
+    'isNaN',
+    'parseFloat',
+    'parseInt',
+    'undefined',
+    'unescape',
+];
+
+// node_modules/@babel/helper-globals/data/builtin-upper.json
+var builtin_upper_default = [
+    'AggregateError',
+    'Array',
+    'ArrayBuffer',
+    'Atomics',
+    'BigInt',
+    'BigInt64Array',
+    'BigUint64Array',
+    'Boolean',
+    'DataView',
+    'Date',
+    'Error',
+    'EvalError',
+    'FinalizationRegistry',
+    'Float16Array',
+    'Float32Array',
+    'Float64Array',
+    'Function',
+    'Infinity',
+    'Int16Array',
+    'Int32Array',
+    'Int8Array',
+    'Intl',
+    'Iterator',
+    'JSON',
+    'Map',
+    'Math',
+    'NaN',
+    'Number',
+    'Object',
+    'Promise',
+    'Proxy',
+    'RangeError',
+    'ReferenceError',
+    'Reflect',
+    'RegExp',
+    'Set',
+    'SharedArrayBuffer',
+    'String',
+    'Symbol',
+    'SyntaxError',
+    'TypeError',
+    'Uint16Array',
+    'Uint32Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'URIError',
+    'WeakMap',
+    'WeakRef',
+    'WeakSet',
+];
+
+// node_modules/@babel/traverse/lib/index.js
 var ReferencedIdentifier = [
     'Identifier',
     'JSXIdentifier',
@@ -46993,7 +43939,7 @@ function verify$1(visitor) {
             continue;
         
         if (!TYPES2.includes(nodeType)) {
-            throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${'8.0.0-beta.1'}`);
+            throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${'8.0.0-beta.2'}`);
         }
         
         const visitors2 = visitor[nodeType];
@@ -47446,9 +44392,6 @@ var cache = /* @__PURE__ */Object.freeze({
     },
 });
 
-var globalsBuiltinLower = require('@babel/helper-globals/data/builtin-lower.json');
-var globalsBuiltinUpper = require('@babel/helper-globals/data/builtin-upper.json');
-
 var {
     assignmentExpression: assignmentExpression$3,
     callExpression: callExpression$3,
@@ -47737,8 +44680,7 @@ var collectorVisitor = {
         },
     },
     LabeledStatement(path) {
-        path
-            .scope
+        path.scope
             .getBlockParent()
             .registerDeclaration(path);
     },
@@ -48491,7 +45433,8 @@ collectorVisitor]));
             const binding = scope2.getOwnBinding(name);
             
             if (binding) {
-                if (previousPath?.isPattern() && binding.kind !== 'param' && binding.kind !== 'local'); else {
+                if (previousPath?.isPattern() && binding.kind !== 'param' && binding.kind !== 'local');
+ else {
                     return binding;
                 }
             } else if (!binding && name === 'arguments' && scope2.path.isFunction() && !scope2.path.isArrowFunctionExpression()) {
@@ -48643,7 +45586,7 @@ collectorVisitor]));
     }
 };
 
-__publicField(_Scope, 'globals', [...globalsBuiltinLower, ...globalsBuiltinUpper]);
+__publicField(_Scope, 'globals', [...builtin_lower_default, ...builtin_upper_default]);
 __publicField(_Scope, 'contextVariables', [
     'arguments',
     'undefined',
@@ -48857,6 +45800,7 @@ function infererReference(node) {
     } else if (node.name === 'NaN' || node.name === 'Infinity') {
         return numberTypeAnnotation$1();
     }    else if (node.name === 'arguments');
+
 }
 
 function getTypeAnnotationBindingConstantViolations(binding, path, name) {
@@ -49238,6 +46182,7 @@ function resolveCall(callee) {
                 return callee.node.returnType;
             } else
 ;
+
         }
     }
 }
@@ -49589,8 +46534,9 @@ function insertBefore(nodes_) {
     } else if (this.isStatementOrBlock()) {
         const node = this.node;
         const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-        this.replaceWith(blockStatement$2(shouldInsertCurrentNode ? [node] : []));
-        return this.unshiftContainer('body', nodes2);
+        const [blockPath] = this.replaceWith(blockStatement$2(shouldInsertCurrentNode ? [node] : []));
+        
+        return blockPath.unshiftContainer('body', nodes2);
     } else {
         throw new Error('We don\'t know what to do with this node type. We were previously a Statement but we can\'t fit in here?');
     }
@@ -49708,8 +46654,9 @@ function insertAfter(nodes_) {
     } else if (this.isStatementOrBlock()) {
         const node = this.node;
         const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-        this.replaceWith(blockStatement$2(shouldInsertCurrentNode ? [node] : []));
-        return this.pushContainer('body', nodes2);
+        const [blockPath] = this.replaceWith(blockStatement$2(shouldInsertCurrentNode ? [node] : []));
+        
+        return blockPath.pushContainer('body', nodes2);
     } else {
         throw new Error('We don\'t know what to do with this node type. We were previously a Statement but we can\'t fit in here?');
     }
@@ -49768,16 +46715,18 @@ function _verifyNodeList(nodes2) {
 
 function unshiftContainer(listKey, nodes2) {
     _assertUnremoved.call(this);
-    nodes2 = _verifyNodeList.call(this, nodes2);
+    const verifiedNodes = _verifyNodeList.call(this, nodes2);
+    const container = this.node[listKey];
+    
     const path = NodePath_Final.get({
         parentPath: this,
         parent: this.node,
-        container: this.node[listKey],
+        container,
         listKey,
         key: 0,
     }).setContext(this.context);
     
-    return _containerInsertBefore.call(path, nodes2);
+    return _containerInsertBefore.call(path, verifiedNodes);
 }
 
 function pushContainer(listKey, nodes2) {
@@ -49829,9 +46778,9 @@ var {
 
 function replaceWithMultiple(nodes2) {
     resync.call(this);
-    nodes2 = _verifyNodeList.call(this, nodes2);
-    inheritLeadingComments2(nodes2[0], this.node);
-    inheritTrailingComments2(nodes2[nodes2.length - 1], this.node);
+    const verifiedNodes = _verifyNodeList.call(this, nodes2);
+    inheritLeadingComments2(verifiedNodes[0], this.node);
+    inheritTrailingComments2(verifiedNodes[verifiedNodes.length - 1], this.node);
     getCachedPaths(this)?.delete(this.node);
     this.node =
     this.container[this.key] = null;