@putout/bundle 4.6.6 → 4.6.7

package/bundle/putout.js

@@ -11209,196 +11209,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)
@@ -21125,7 +20944,7 @@ function removeTypeDuplicates$1(nodesIn) {
             return [node];
         }
         
-        if (isFlowBaseAnnotation(node)) {
+        if (isFlowBaseAnnotation()) {
             bases.set(node.type, node);
             continue;
         }
@@ -23942,10 +23761,6 @@ function tokenIsAssignment(token) {
     return token >= 29 && token <= 33;
 }
 
-function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
-    return token >= 129 && token <= 131;
-}
-
 function tokenIsLoop(token) {
     return token >= 90 && token <= 92;
 }
@@ -25062,10 +24877,6 @@ function isKeyword2(word) {
     return keywords2.has(word);
 }
 
-function isIteratorStart(current, next, next2) {
-    return current === 64 && next === 64 && isIdentifierStart2(next2);
-}
-
 var reservedWordLikeSet = /* @__PURE__ */new Set([
     'break',
     'case',
@@ -25147,3209 +24958,174 @@ var ScopeHandler = class {
     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$17.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$17.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$17.j_oTag || currentContext === types$17.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);
-    }
-    
-    parseParenAndDistinguishExpression(canBeArrow) {
-        return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
-    }
-    
-    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);
-    }
-    
-    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);
-    }
-    
-    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,
-            });
-        }
-        
-        const {value} = this.state;
-        
-        this.next();
-        
-        if (value !== 'boolean' && value !== 'number' && value !== 'string' && value !== 'symbol') {
-            this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
-                enumName,
-                invalidEnumType: value,
+    checkRedeclarationInScope(scope2, name, bindingType, loc) {
+        if (this.isRedeclaredInScope(scope2, name, bindingType)) {
+            this.parser.raise(Errors.VarRedeclaration, loc, {
+                identifierName: name,
             });
         }
-        
-        return value;
     }
     
-    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');
+    isRedeclaredInScope(scope2, name, bindingType) {
+        if (!(bindingType & 1))
+            return false;
         
-        case 'string':
-            node.explicitType = true;
-            node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-                enumName,
-            });
-            this.expect(8);
-            return this.finishNode(node, 'EnumStringBody');
+        if (bindingType & 8) {
+            return scope2.names.has(name);
+        }
         
-        case 'symbol':
-            node.members = members.defaultedMembers;
-            this.expect(8);
-            return this.finishNode(node, 'EnumSymbolBody');
+        const type = scope2.names.get(name);
         
-        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 (bindingType & 16) {
+            return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope2) && (type & 1) > 0;
         }
-    }
-    
-    flowParseEnumDeclaration(node) {
-        const id = this.parseIdentifier();
         
-        node.id = id;
-        node.body = this.flowEnumBody(this.startNode(), id);
-        return this.finishNode(node, 'EnumDeclaration');
+        return (type & 2) > 0 && !(scope2.flags & 8 && scope2.firstLexicalName === name)
+            || !this.treatFunctionsAsVarInScope(scope2) && (type & 4) > 0;
     }
     
-    jsxParseOpeningElementAfterName(node) {
-        if (this.shouldParseTypes()) {
-            if (this.match(47) || this.match(51)) {
-                node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
-            }
-        }
+    checkLocalExport(id) {
+        const {name} = id;
         
-        return super.jsxParseOpeningElementAfterName(node);
-    }
-    
-    isLookaheadToken_lt() {
-        const next = this.nextTokenStart();
+        const topLevelScope = this.scopeStack[0];
         
-        if (this.input.charCodeAt(next) === 60) {
-            const afterNext = this.input.charCodeAt(next + 1);
-            return afterNext !== 60 && afterNext !== 61;
+        if (!topLevelScope.names.has(name)) {
+            this.undefinedExports.set(name, id.loc.start);
         }
-        
-        return false;
     }
     
-    reScan_lt_gt() {
-        const {type} = this.state;
-        
-        if (type === 47) {
-            this.state.pos -= 1;
-            this.readToken_lt();
-        } else if (type === 48) {
-            this.state.pos -= 1;
-            this.readToken_gt();
-        }
+    currentScope() {
+        return this.scopeStack[this.scopeStack.length - 1];
     }
     
-    reScan_lt() {
-        const {type} = this.state;
-        
-        if (type === 51) {
-            this.state.pos -= 2;
-            this.finishOp(47, 1);
-            return 47;
+    currentVarScopeFlags() {
+        for (let i = this.scopeStack.length - 1;; i--) {
+            const {flags} = this.scopeStack[i];
+            
+            if (flags & 1667) {
+                return flags;
+            }
         }
-        
-        return type;
     }
     
-    maybeUnwrapTypeCastExpression(node) {
-        return node.type === 'TypeCastExpression' ? node.expression : node;
+    currentThisScopeFlags() {
+        for (let i = this.scopeStack.length - 1;; i--) {
+            const {flags} = this.scopeStack[i];
+            
+            if (flags & (1667 | 64) && !(flags & 4)) {
+                return flags;
+            }
+        }
     }
 };
 
@@ -36646,7 +33422,6 @@ function validatePlugins(pluginsMap) {
 var mixinPlugins = {
     estree,
     jsx: jsx$3,
-    flow,
     typescript: typescript$3,
     v8intrinsic,
     placeholders,
@@ -66216,356 +62991,11 @@ var esprima$2 = /*#__PURE__*/Object.freeze({
 
 var require$$1$1 = /*@__PURE__*/getAugmentedNamespace(esprima$2);
 
-var acornPrivateClassElements;
-var hasRequiredAcornPrivateClassElements;
-
-function requireAcornPrivateClassElements () {
-	if (hasRequiredAcornPrivateClassElements) return acornPrivateClassElements;
-	hasRequiredAcornPrivateClassElements = 1;
-
-	const getPrototype = Object.getPrototypeOf || (o => o.__proto__);
-
-	const getAcorn = Parser => {
-	  if (Parser.acorn) return Parser.acorn
-
-	  const acorn = require$$1$1;
-
-	  if (acorn.version.indexOf("6.") != 0 && acorn.version.indexOf("6.0.") == 0 && acorn.version.indexOf("7.") != 0) {
-	    throw new Error(`acorn-private-class-elements requires acorn@^6.1.0 or acorn@7.0.0, not ${acorn.version}`)
-	  }
-
-	  // Make sure `Parser` comes from the same acorn as we `require`d,
-	  // otherwise the comparisons fail.
-	  for (let cur = Parser; cur && cur !== acorn.Parser; cur = getPrototype(cur)) {
-	    if (cur !== acorn.Parser) {
-	      throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
-	    }
-	  }
-	  return acorn
-	};
-
-	acornPrivateClassElements = function(Parser) {
-	  // Only load this plugin once.
-	  if (Parser.prototype.parsePrivateName) {
-	    return Parser
-	  }
-
-	  const acorn = getAcorn(Parser);
-
-	  Parser = class extends Parser {
-	    _branch() {
-	      this.__branch = this.__branch || new Parser({ecmaVersion: this.options.ecmaVersion}, this.input);
-	      this.__branch.end = this.end;
-	      this.__branch.pos = this.pos;
-	      this.__branch.type = this.type;
-	      this.__branch.value = this.value;
-	      this.__branch.containsEsc = this.containsEsc;
-	      return this.__branch
-	    }
-
-	    parsePrivateClassElementName(element) {
-	      element.computed = false;
-	      element.key = this.parsePrivateName();
-	      if (element.key.name == "constructor") this.raise(element.key.start, "Classes may not have a private element named constructor");
-	      const accept = {get: "set", set: "get"}[element.kind];
-	      const privateBoundNames = this._privateBoundNames;
-	      if (Object.prototype.hasOwnProperty.call(privateBoundNames, element.key.name) && privateBoundNames[element.key.name] !== accept) {
-	        this.raise(element.start, "Duplicate private element");
-	      }
-	      privateBoundNames[element.key.name] = element.kind || true;
-	      delete this._unresolvedPrivateNames[element.key.name];
-	      return element.key
-	    }
-
-	    parsePrivateName() {
-	      const node = this.startNode();
-	      node.name = this.value;
-	      this.next();
-	      this.finishNode(node, "PrivateName");
-	      if (this.options.allowReserved == "never") this.checkUnreserved(node);
-	      return node
-	    }
-
-	    // Parse # token
-	    getTokenFromCode(code) {
-	      if (code === 35) {
-	        ++this.pos;
-	        const word = this.readWord1();
-	        return this.finishToken(this.privateNameToken, word)
-	      }
-	      return super.getTokenFromCode(code)
-	    }
-
-	    // Manage stacks and check for undeclared private names
-	    parseClass(node, isStatement) {
-	      const oldOuterPrivateBoundNames = this._outerPrivateBoundNames;
-	      this._outerPrivateBoundNames = this._privateBoundNames;
-	      this._privateBoundNames = Object.create(this._privateBoundNames || null);
-	      const oldOuterUnresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-	      this._outerUnresolvedPrivateNames = this._unresolvedPrivateNames;
-	      this._unresolvedPrivateNames = Object.create(null);
-
-	      const _return = super.parseClass(node, isStatement);
-
-	      const unresolvedPrivateNames = this._unresolvedPrivateNames;
-	      this._privateBoundNames = this._outerPrivateBoundNames;
-	      this._outerPrivateBoundNames = oldOuterPrivateBoundNames;
-	      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-	      this._outerUnresolvedPrivateNames = oldOuterUnresolvedPrivateNames;
-	      if (!this._unresolvedPrivateNames) {
-	        const names = Object.keys(unresolvedPrivateNames);
-	        if (names.length) {
-	          names.sort((n1, n2) => unresolvedPrivateNames[n1] - unresolvedPrivateNames[n2]);
-	          this.raise(unresolvedPrivateNames[names[0]], "Usage of undeclared private name");
-	        }
-	      } else Object.assign(this._unresolvedPrivateNames, unresolvedPrivateNames);
-	      return _return
-	    }
-
-	    // Class heritage is evaluated with outer private environment
-	    parseClassSuper(node) {
-	      const privateBoundNames = this._privateBoundNames;
-	      this._privateBoundNames = this._outerPrivateBoundNames;
-	      const unresolvedPrivateNames = this._unresolvedPrivateNames;
-	      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-	      const _return = super.parseClassSuper(node);
-	      this._privateBoundNames = privateBoundNames;
-	      this._unresolvedPrivateNames = unresolvedPrivateNames;
-	      return _return
-	    }
-
-	    // Parse private element access
-	    parseSubscript(base, startPos, startLoc, _noCalls, _maybeAsyncArrow, _optionalChained) {
-	      const optionalSupported = this.options.ecmaVersion >= 11 && acorn.tokTypes.questionDot;
-	      const branch = this._branch();
-	      if (!(
-	        (branch.eat(acorn.tokTypes.dot) || (optionalSupported && branch.eat(acorn.tokTypes.questionDot))) &&
-	        branch.type == this.privateNameToken
-	      )) {
-	        return super.parseSubscript.apply(this, arguments)
-	      }
-	      let optional = false;
-	      if (!this.eat(acorn.tokTypes.dot)) {
-	        this.expect(acorn.tokTypes.questionDot);
-	        optional = true;
-	      }
-	      let node = this.startNodeAt(startPos, startLoc);
-	      node.object = base;
-	      node.computed = false;
-	      if (optionalSupported) {
-	        node.optional = optional;
-	      }
-	      if (this.type == this.privateNameToken) {
-	        if (base.type == "Super") {
-	          this.raise(this.start, "Cannot access private element on super");
-	        }
-	        node.property = this.parsePrivateName();
-	        if (!this._privateBoundNames || !this._privateBoundNames[node.property.name]) {
-	          if (!this._unresolvedPrivateNames) {
-	            this.raise(node.property.start, "Usage of undeclared private name");
-	          }
-	          this._unresolvedPrivateNames[node.property.name] = node.property.start;
-	        }
-	      } else {
-	        node.property = this.parseIdent(true);
-	      }
-	      return this.finishNode(node, "MemberExpression")
-	    }
-
-	    // Prohibit delete of private class elements
-	    parseMaybeUnary(refDestructuringErrors, sawUnary) {
-	      const _return = super.parseMaybeUnary(refDestructuringErrors, sawUnary);
-	      if (_return.operator == "delete") {
-	        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateName") {
-	          this.raise(_return.start, "Private elements may not be deleted");
-	        }
-	      }
-	      return _return
-	    }
-	  };
-	  Parser.prototype.privateNameToken = new acorn.TokenType("privateName");
-	  return Parser
-	};
-	return acornPrivateClassElements;
-}
-
-var acornClassFields;
-var hasRequiredAcornClassFields;
-
-function requireAcornClassFields () {
-	if (hasRequiredAcornClassFields) return acornClassFields;
-	hasRequiredAcornClassFields = 1;
-
-	const privateClassElements = requireAcornPrivateClassElements();
-
-	acornClassFields = function(Parser) {
-	  const acorn = Parser.acorn || require$$1$1;
-	  const tt = acorn.tokTypes;
-
-	  Parser = privateClassElements(Parser);
-	  return class extends Parser {
-	    _maybeParseFieldValue(field) {
-	      if (this.eat(tt.eq)) {
-	        const oldInFieldValue = this._inFieldValue;
-	        this._inFieldValue = true;
-	        if (this.type === tt.name && this.value === "await" && (this.inAsync || this.options.allowAwaitOutsideFunction)) {
-	          field.value = this.parseAwait();
-	        } else field.value = this.parseExpression();
-	        this._inFieldValue = oldInFieldValue;
-	      } else field.value = null;
-	    }
-
-	    // Parse fields
-	    parseClassElement(_constructorAllowsSuper) {
-	      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type.keyword || this.type == this.privateNameToken || this.type == tt.bracketL || this.type == tt.string || this.type == tt.num)) {
-	        const branch = this._branch();
-	        if (branch.type == tt.bracketL) {
-	          let count = 0;
-	          do {
-	            if (branch.eat(tt.bracketL)) ++count;
-	            else if (branch.eat(tt.bracketR)) --count;
-	            else branch.next();
-	          } while (count > 0)
-	        } else branch.next(true);
-	        let isField = branch.type == tt.eq || branch.type == tt.semi;
-	        if (!isField && branch.canInsertSemicolon()) {
-	          isField = branch.type != tt.parenL;
-	        }
-	        if (isField) {
-	          const node = this.startNode();
-	          if (this.type == this.privateNameToken) {
-	            this.parsePrivateClassElementName(node);
-	          } else {
-	            this.parsePropertyName(node);
-	          }
-	          if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-	              (node.key.type === "Literal" && node.key.value === "constructor")) {
-	            this.raise(node.key.start, "Classes may not have a field called constructor");
-	          }
-	          this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
-	          this._maybeParseFieldValue(node);
-	          this.exitScope();
-	          this.finishNode(node, "FieldDefinition");
-	          this.semicolon();
-	          return node
-	        }
-	      }
-
-	      return super.parseClassElement.apply(this, arguments)
-	    }
-
-	    // Prohibit arguments in class field initializers
-	    parseIdent(liberal, isBinding) {
-	      const ident = super.parseIdent(liberal, isBinding);
-	      if (this._inFieldValue && ident.name == "arguments") this.raise(ident.start, "A class field initializer may not contain arguments");
-	      return ident
-	    }
-	  }
-	};
-	return acornClassFields;
-}
-
-var acornStaticClassFeatures;
-var hasRequiredAcornStaticClassFeatures;
-
-function requireAcornStaticClassFeatures () {
-	if (hasRequiredAcornStaticClassFeatures) return acornStaticClassFeatures;
-	hasRequiredAcornStaticClassFeatures = 1;
-
-	const privateClassElements = requireAcornPrivateClassElements();
-
-	acornStaticClassFeatures = function(Parser) {
-	  const ExtendedParser = privateClassElements(Parser);
-
-	  const acorn = Parser.acorn || require$$1$1;
-	  const tt = acorn.tokTypes;
-
-	  return class extends ExtendedParser {
-	    _maybeParseFieldValue(field) {
-	      if (this.eat(tt.eq)) {
-	        const oldInFieldValue = this._inStaticFieldScope;
-	        this._inStaticFieldScope = this.currentThisScope();
-	        field.value = this.parseExpression();
-	        this._inStaticFieldScope = oldInFieldValue;
-	      } else field.value = null;
-	    }
-
-	    // Parse fields
-	    parseClassElement(_constructorAllowsSuper) {
-	      if (this.options.ecmaVersion < 8 || !this.isContextual("static")) {
-	        return super.parseClassElement.apply(this, arguments)
-	      }
-
-	      const branch = this._branch();
-	      branch.next();
-	      if ([tt.name, tt.bracketL, tt.string, tt.num, this.privateNameToken].indexOf(branch.type) == -1 && !branch.type.keyword) {
-	        return super.parseClassElement.apply(this, arguments)
-	      }
-	      if (branch.type == tt.bracketL) {
-	        let count = 0;
-	        do {
-	          if (branch.eat(tt.bracketL)) ++count;
-	          else if (branch.eat(tt.bracketR)) --count;
-	          else branch.next();
-	        } while (count > 0)
-	      } else branch.next();
-	      if (branch.type != tt.eq && !branch.canInsertSemicolon() && branch.type != tt.semi) {
-	        return super.parseClassElement.apply(this, arguments)
-	      }
-
-	      const node = this.startNode();
-	      node.static = this.eatContextual("static");
-	      if (this.type == this.privateNameToken) {
-	        this.parsePrivateClassElementName(node);
-	      } else {
-	        this.parsePropertyName(node);
-	      }
-	      if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-	          (node.key.type === "Literal" && !node.computed && node.key.value === "constructor")) {
-	        this.raise(node.key.start, "Classes may not have a field called constructor");
-	      }
-	      if ((node.key.name || node.key.value) === "prototype" && !node.computed) {
-	        this.raise(node.key.start, "Classes may not have a static property named prototype");
-	      }
-
-	      this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
-	      this._maybeParseFieldValue(node);
-	      this.exitScope();
-	      this.finishNode(node, "FieldDefinition");
-	      this.semicolon();
-	      return node
-	    }
-
-	    // Parse private static methods
-	    parsePropertyName(prop) {
-	      if (prop.static && this.type == this.privateNameToken) {
-	        this.parsePrivateClassElementName(prop);
-	      } else {
-	        super.parsePropertyName(prop);
-	      }
-	    }
-
-	    // Prohibit arguments in class field initializers
-	    parseIdent(liberal, isBinding) {
-	      const ident = super.parseIdent(liberal, isBinding);
-	      if (this._inStaticFieldScope && this.currentThisScope() === this._inStaticFieldScope && ident.name == "arguments") {
-	        this.raise(ident.start, "A static class field initializer may not contain arguments");
-	      }
-	      return ident
-	    }
-	  }
-	};
-	return acornStaticClassFeatures;
-}
-
-var acornPrivateClassElementsExports = requireAcornPrivateClassElements();
-var privateClassElements = acornPrivateClassElementsExports.default;
-
 // eslint-disable-next-line node/no-unsupported-features/es-syntax
 
 // eslint-disable-next-line node/no-unsupported-features/es-syntax
 function privateMethods(Parser) {
-  const ExtendedParser = privateClassElements(Parser);
+  const ExtendedParser = noop$3();
 
   return class extends ExtendedParser {
     // Parse private methods
@@ -66602,8 +63032,8 @@ function requireAcornStage3 () {
 
 	acornStage3 = function(Parser) {
 	  return Parser.extend(
-	    requireAcornClassFields(),
-	    requireAcornStaticClassFeatures(),
+	    require$$1$1,
+	    require$$1$1,
 	    require$$2
 	  )
 	};
@@ -70689,7 +67119,7 @@ compare$5.compareAll = (path, templateNodes, options) => {
 
 // @babel/template creates empty array directives
 // extra duplicate value
-const ignore$3 = [
+const ignore$2 = [
     'loc',
     'start',
     'end',
@@ -70722,7 +67152,7 @@ function superCompareIterate(node, template) {
             return false;
         
         for (const key of keys$2(template)) {
-            if (ignore$3.includes(key))
+            if (ignore$2.includes(key))
                 continue;
             
             const nodeValue = extractExpression(node[key]);
@@ -80934,788 +77364,8 @@ keyword.isTSKeyword = (name) => {
 
 var matchFiles = {};
 
-var ignore$2 = {exports: {}};
-
-(function (module) {
-	// A simple implementation of make-array
-	function makeArray (subject) {
-	  return Array.isArray(subject)
-	    ? subject
-	    : [subject]
-	}
-
-	const UNDEFINED = undefined;
-	const EMPTY = '';
-	const SPACE = ' ';
-	const ESCAPE = '\\';
-	const REGEX_TEST_BLANK_LINE = /^\s+$/;
-	const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
-	const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-	const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-	const REGEX_SPLITALL_CRLF = /\r?\n/g;
-
-	// Invalid:
-	// - /foo,
-	// - ./foo,
-	// - ../foo,
-	// - .
-	// - ..
-	// Valid:
-	// - .foo
-	const REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-
-	const REGEX_TEST_TRAILING_SLASH = /\/$/;
-
-	const SLASH = '/';
-
-	// Do not use ternary expression here, since "istanbul ignore next" is buggy
-	let TMP_KEY_IGNORE = 'node-ignore';
-	/* istanbul ignore else */
-	if (typeof Symbol !== 'undefined') {
-	  TMP_KEY_IGNORE = Symbol.for('node-ignore');
-	}
-	const KEY_IGNORE = TMP_KEY_IGNORE;
-
-	const define = (object, key, value) => {
-	  Object.defineProperty(object, key, {value});
-	  return value
-	};
-
-	const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-
-	const RETURN_FALSE = () => false;
-
-	// Sanitize the range of a regular expression
-	// The cases are complicated, see test cases for details
-	const sanitizeRange = range => range.replace(
-	  REGEX_REGEXP_RANGE,
-	  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
-	    ? match
-	    // Invalid range (out of order) which is ok for gitignore rules but
-	    //   fatal for JavaScript regular expression, so eliminate it.
-	    : EMPTY
-	);
-
-	// See fixtures #59
-	const cleanRangeBackSlash = slashes => {
-	  const {length} = slashes;
-	  return slashes.slice(0, length - length % 2)
-	};
-
-	// > If the pattern ends with a slash,
-	// > it is removed for the purpose of the following description,
-	// > but it would only find a match with a directory.
-	// > In other words, foo/ will match a directory foo and paths underneath it,
-	// > but will not match a regular file or a symbolic link foo
-	// >  (this is consistent with the way how pathspec works in general in Git).
-	// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
-	// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
-	//      you could use option `mark: true` with `glob`
-
-	// '`foo/`' should not continue with the '`..`'
-	const REPLACERS = [
-
-	  [
-	    // Remove BOM
-	    // TODO:
-	    // Other similar zero-width characters?
-	    /^\uFEFF/,
-	    () => EMPTY
-	  ],
-
-	  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-	  [
-	    // (a\ ) -> (a )
-	    // (a  ) -> (a)
-	    // (a ) -> (a)
-	    // (a \ ) -> (a  )
-	    /((?:\\\\)*?)(\\?\s+)$/,
-	    (_, m1, m2) => m1 + (
-	      m2.indexOf('\\') === 0
-	        ? SPACE
-	        : EMPTY
-	    )
-	  ],
-
-	  // Replace (\ ) with ' '
-	  // (\ ) -> ' '
-	  // (\\ ) -> '\\ '
-	  // (\\\ ) -> '\\ '
-	  [
-	    /(\\+?)\s/g,
-	    (_, m1) => {
-	      const {length} = m1;
-	      return m1.slice(0, length - length % 2) + SPACE
-	    }
-	  ],
-
-	  // Escape metacharacters
-	  // which is written down by users but means special for regular expressions.
-
-	  // > There are 12 characters with special meanings:
-	  // > - the backslash \,
-	  // > - the caret ^,
-	  // > - the dollar sign $,
-	  // > - the period or dot .,
-	  // > - the vertical bar or pipe symbol |,
-	  // > - the question mark ?,
-	  // > - the asterisk or star *,
-	  // > - the plus sign +,
-	  // > - the opening parenthesis (,
-	  // > - the closing parenthesis ),
-	  // > - and the opening square bracket [,
-	  // > - the opening curly brace {,
-	  // > These special characters are often called "metacharacters".
-	  [
-	    /[\\$.|*+(){^]/g,
-	    match => `\\${match}`
-	  ],
-
-	  [
-	    // > a question mark (?) matches a single character
-	    /(?!\\)\?/g,
-	    () => '[^/]'
-	  ],
-
-	  // leading slash
-	  [
-
-	    // > A leading slash matches the beginning of the pathname.
-	    // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
-	    // A leading slash matches the beginning of the pathname
-	    /^\//,
-	    () => '^'
-	  ],
-
-	  // replace special metacharacter slash after the leading slash
-	  [
-	    /\//g,
-	    () => '\\/'
-	  ],
-
-	  [
-	    // > A leading "**" followed by a slash means match in all directories.
-	    // > For example, "**/foo" matches file or directory "foo" anywhere,
-	    // > the same as pattern "foo".
-	    // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
-	    // >   under directory "foo".
-	    // Notice that the '*'s have been replaced as '\\*'
-	    /^\^*\\\*\\\*\\\//,
-
-	    // '**/foo' <-> 'foo'
-	    () => '^(?:.*\\/)?'
-	  ],
-
-	  // starting
-	  [
-	    // there will be no leading '/'
-	    //   (which has been replaced by section "leading slash")
-	    // If starts with '**', adding a '^' to the regular expression also works
-	    /^(?=[^^])/,
-	    function startingReplacer () {
-	      // If has a slash `/` at the beginning or middle
-	      return !/\/(?!$)/.test(this)
-	        // > Prior to 2.22.1
-	        // > If the pattern does not contain a slash /,
-	        // >   Git treats it as a shell glob pattern
-	        // Actually, if there is only a trailing slash,
-	        //   git also treats it as a shell glob pattern
-
-	        // After 2.22.1 (compatible but clearer)
-	        // > If there is a separator at the beginning or middle (or both)
-	        // > of the pattern, then the pattern is relative to the directory
-	        // > level of the particular .gitignore file itself.
-	        // > Otherwise the pattern may also match at any level below
-	        // > the .gitignore level.
-	        ? '(?:^|\\/)'
-
-	        // > Otherwise, Git treats the pattern as a shell glob suitable for
-	        // >   consumption by fnmatch(3)
-	        : '^'
-	    }
-	  ],
-
-	  // two globstars
-	  [
-	    // Use lookahead assertions so that we could match more than one `'/**'`
-	    /\\\/\\\*\\\*(?=\\\/|$)/g,
-
-	    // Zero, one or several directories
-	    // should not use '*', or it will be replaced by the next replacer
-
-	    // Check if it is not the last `'/**'`
-	    (_, index, str) => index + 6 < str.length
-
-	      // case: /**/
-	      // > A slash followed by two consecutive asterisks then a slash matches
-	      // >   zero or more directories.
-	      // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
-	      // '/**/'
-	      ? '(?:\\/[^\\/]+)*'
-
-	      // case: /**
-	      // > A trailing `"/**"` matches everything inside.
-
-	      // #21: everything inside but it should not include the current folder
-	      : '\\/.+'
-	  ],
-
-	  // normal intermediate wildcards
-	  [
-	    // Never replace escaped '*'
-	    // ignore rule '\*' will match the path '*'
-
-	    // 'abc.*/' -> go
-	    // 'abc.*'  -> skip this rule,
-	    //    coz trailing single wildcard will be handed by [trailing wildcard]
-	    /(^|[^\\]+)(\\\*)+(?=.+)/g,
-
-	    // '*.js' matches '.js'
-	    // '*.js' doesn't match 'abc'
-	    (_, p1, p2) => {
-	      // 1.
-	      // > An asterisk "*" matches anything except a slash.
-	      // 2.
-	      // > Other consecutive asterisks are considered regular asterisks
-	      // > and will match according to the previous rules.
-	      const unescaped = p2.replace(/\\\*/g, '[^\\/]*');
-	      return p1 + unescaped
-	    }
-	  ],
-
-	  [
-	    // unescape, revert step 3 except for back slash
-	    // For example, if a user escape a '\\*',
-	    // after step 3, the result will be '\\\\\\*'
-	    /\\\\\\(?=[$.|*+(){^])/g,
-	    () => ESCAPE
-	  ],
-
-	  [
-	    // '\\\\' -> '\\'
-	    /\\\\/g,
-	    () => ESCAPE
-	  ],
-
-	  [
-	    // > The range notation, e.g. [a-zA-Z],
-	    // > can be used to match one of the characters in a range.
-
-	    // `\` is escaped by step 3
-	    /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-	    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE
-	      // '\\[bar]' -> '\\\\[bar\\]'
-	      ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`
-	      : close === ']'
-	        ? endEscape.length % 2 === 0
-	          // A normal case, and it is a range notation
-	          // '[bar]'
-	          // '[bar\\\\]'
-	          ? `[${sanitizeRange(range)}${endEscape}]`
-	          // Invalid range notaton
-	          // '[bar\\]' -> '[bar\\\\]'
-	          : '[]'
-	        : '[]'
-	  ],
-
-	  // ending
-	  [
-	    // 'js' will not match 'js.'
-	    // 'ab' will not match 'abc'
-	    /(?:[^*])$/,
-
-	    // WTF!
-	    // https://git-scm.com/docs/gitignore
-	    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
-	    // which re-fixes #24, #38
-
-	    // > If there is a separator at the end of the pattern then the pattern
-	    // > will only match directories, otherwise the pattern can match both
-	    // > files and directories.
-
-	    // 'js*' will not match 'a.js'
-	    // 'js/' will not match 'a.js'
-	    // 'js' will match 'a.js' and 'a.js/'
-	    match => /\/$/.test(match)
-	      // foo/ will not match 'foo'
-	      ? `${match}$`
-	      // foo matches 'foo' and 'foo/'
-	      : `${match}(?=$|\\/$)`
-	  ]
-	];
-
-	const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
-	const MODE_IGNORE = 'regex';
-	const MODE_CHECK_IGNORE = 'checkRegex';
-	const UNDERSCORE = '_';
-
-	const TRAILING_WILD_CARD_REPLACERS = {
-	  [MODE_IGNORE] (_, p1) {
-	    const prefix = p1
-	      // '\^':
-	      // '/*' does not match EMPTY
-	      // '/*' does not match everything
-
-	      // '\\\/':
-	      // 'abc/*' does not match 'abc/'
-	      ? `${p1}[^/]+`
-
-	      // 'a*' matches 'a'
-	      // 'a*' matches 'aa'
-	      : '[^/]*';
-
-	    return `${prefix}(?=$|\\/$)`
-	  },
-
-	  [MODE_CHECK_IGNORE] (_, p1) {
-	    // When doing `git check-ignore`
-	    const prefix = p1
-	      // '\\\/':
-	      // 'abc/*' DOES match 'abc/' !
-	      ? `${p1}[^/]*`
-
-	      // 'a*' matches 'a'
-	      // 'a*' matches 'aa'
-	      : '[^/]*';
-
-	    return `${prefix}(?=$|\\/$)`
-	  }
-	};
-
-	// @param {pattern}
-	const makeRegexPrefix = pattern => REPLACERS.reduce(
-	  (prev, [matcher, replacer]) =>
-	    prev.replace(matcher, replacer.bind(pattern)),
-	  pattern
-	);
-
-	const isString = subject => typeof subject === 'string';
-
-	// > A blank line matches no files, so it can serve as a separator for readability.
-	const checkPattern = pattern => pattern
-	  && isString(pattern)
-	  && !REGEX_TEST_BLANK_LINE.test(pattern)
-	  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
-
-	  // > A line starting with # serves as a comment.
-	  && pattern.indexOf('#') !== 0;
-
-	const splitPattern = pattern => pattern
-	.split(REGEX_SPLITALL_CRLF)
-	.filter(Boolean);
-
-	class IgnoreRule {
-	  constructor (
-	    pattern,
-	    mark,
-	    body,
-	    ignoreCase,
-	    negative,
-	    prefix
-	  ) {
-	    this.pattern = pattern;
-	    this.mark = mark;
-	    this.negative = negative;
-
-	    define(this, 'body', body);
-	    define(this, 'ignoreCase', ignoreCase);
-	    define(this, 'regexPrefix', prefix);
-	  }
-
-	  get regex () {
-	    const key = UNDERSCORE + MODE_IGNORE;
-
-	    if (this[key]) {
-	      return this[key]
-	    }
-
-	    return this._make(MODE_IGNORE, key)
-	  }
-
-	  get checkRegex () {
-	    const key = UNDERSCORE + MODE_CHECK_IGNORE;
-
-	    if (this[key]) {
-	      return this[key]
-	    }
-
-	    return this._make(MODE_CHECK_IGNORE, key)
-	  }
-
-	  _make (mode, key) {
-	    const str = this.regexPrefix.replace(
-	      REGEX_REPLACE_TRAILING_WILDCARD,
-
-	      // It does not need to bind pattern
-	      TRAILING_WILD_CARD_REPLACERS[mode]
-	    );
-
-	    const regex = this.ignoreCase
-	      ? new RegExp(str, 'i')
-	      : new RegExp(str);
-
-	    return define(this, key, regex)
-	  }
-	}
-
-	const createRule = ({
-	  pattern,
-	  mark
-	}, ignoreCase) => {
-	  let negative = false;
-	  let body = pattern;
-
-	  // > An optional prefix "!" which negates the pattern;
-	  if (body.indexOf('!') === 0) {
-	    negative = true;
-	    body = body.substr(1);
-	  }
-
-	  body = body
-	  // > Put a backslash ("\") in front of the first "!" for patterns that
-	  // >   begin with a literal "!", for example, `"\!important!.txt"`.
-	  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
-	  // > Put a backslash ("\") in front of the first hash for patterns that
-	  // >   begin with a hash.
-	  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');
-
-	  const regexPrefix = makeRegexPrefix(body);
-
-	  return new IgnoreRule(
-	    pattern,
-	    mark,
-	    body,
-	    ignoreCase,
-	    negative,
-	    regexPrefix
-	  )
-	};
-
-	class RuleManager {
-	  constructor (ignoreCase) {
-	    this._ignoreCase = ignoreCase;
-	    this._rules = [];
-	  }
-
-	  _add (pattern) {
-	    // #32
-	    if (pattern && pattern[KEY_IGNORE]) {
-	      this._rules = this._rules.concat(pattern._rules._rules);
-	      this._added = true;
-	      return
-	    }
-
-	    if (isString(pattern)) {
-	      pattern = {
-	        pattern
-	      };
-	    }
-
-	    if (checkPattern(pattern.pattern)) {
-	      const rule = createRule(pattern, this._ignoreCase);
-	      this._added = true;
-	      this._rules.push(rule);
-	    }
-	  }
-
-	  // @param {Array<string> | string | Ignore} pattern
-	  add (pattern) {
-	    this._added = false;
-
-	    makeArray(
-	      isString(pattern)
-	        ? splitPattern(pattern)
-	        : pattern
-	    ).forEach(this._add, this);
-
-	    return this._added
-	  }
-
-	  // Test one single path without recursively checking parent directories
-	  //
-	  // - checkUnignored `boolean` whether should check if the path is unignored,
-	  //   setting `checkUnignored` to `false` could reduce additional
-	  //   path matching.
-	  // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
-
-	  // @returns {TestResult} true if a file is ignored
-	  test (path, checkUnignored, mode) {
-	    let ignored = false;
-	    let unignored = false;
-	    let matchedRule;
-
-	    this._rules.forEach(rule => {
-	      const {negative} = rule;
-
-	      //          |           ignored : unignored
-	      // -------- | ---------------------------------------
-	      // negative |   0:0   |   0:1   |   1:0   |   1:1
-	      // -------- | ------- | ------- | ------- | --------
-	      //     0    |  TEST   |  TEST   |  SKIP   |    X
-	      //     1    |  TESTIF |  SKIP   |  TEST   |    X
-
-	      // - SKIP: always skip
-	      // - TEST: always test
-	      // - TESTIF: only test if checkUnignored
-	      // - X: that never happen
-	      if (
-	        unignored === negative && ignored !== unignored
-	        || negative && !ignored && !unignored && !checkUnignored
-	      ) {
-	        return
-	      }
-
-	      const matched = rule[mode].test(path);
-
-	      if (!matched) {
-	        return
-	      }
-
-	      ignored = !negative;
-	      unignored = negative;
-
-	      matchedRule = negative
-	        ? UNDEFINED
-	        : rule;
-	    });
-
-	    const ret = {
-	      ignored,
-	      unignored
-	    };
-
-	    if (matchedRule) {
-	      ret.rule = matchedRule;
-	    }
-
-	    return ret
-	  }
-	}
-
-	const throwError = (message, Ctor) => {
-	  throw new Ctor(message)
-	};
-
-	const checkPath = (path, originalPath, doThrow) => {
-	  if (!isString(path)) {
-	    return doThrow(
-	      `path must be a string, but got \`${originalPath}\``,
-	      TypeError
-	    )
-	  }
-
-	  // We don't know if we should ignore EMPTY, so throw
-	  if (!path) {
-	    return doThrow(`path must not be empty`, TypeError)
-	  }
-
-	  // Check if it is a relative path
-	  if (checkPath.isNotRelative(path)) {
-	    const r = '`path.relative()`d';
-	    return doThrow(
-	      `path should be a ${r} string, but got "${originalPath}"`,
-	      RangeError
-	    )
-	  }
-
-	  return true
-	};
-
-	const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);
-
-	checkPath.isNotRelative = isNotRelative;
-
-	// On windows, the following function will be replaced
-	/* istanbul ignore next */
-	checkPath.convert = p => p;
-
-
-	class Ignore {
-	  constructor ({
-	    ignorecase = true,
-	    ignoreCase = ignorecase,
-	    allowRelativePaths = false
-	  } = {}) {
-	    define(this, KEY_IGNORE, true);
-
-	    this._rules = new RuleManager(ignoreCase);
-	    this._strictPathCheck = !allowRelativePaths;
-	    this._initCache();
-	  }
-
-	  _initCache () {
-	    // A cache for the result of `.ignores()`
-	    this._ignoreCache = Object.create(null);
-
-	    // A cache for the result of `.test()`
-	    this._testCache = Object.create(null);
-	  }
-
-	  add (pattern) {
-	    if (this._rules.add(pattern)) {
-	      // Some rules have just added to the ignore,
-	      //   making the behavior changed,
-	      //   so we need to re-initialize the result cache
-	      this._initCache();
-	    }
-
-	    return this
-	  }
-
-	  // legacy
-	  addPattern (pattern) {
-	    return this.add(pattern)
-	  }
-
-	  // @returns {TestResult}
-	  _test (originalPath, cache, checkUnignored, slices) {
-	    const path = originalPath
-	      // Supports nullable path
-	      && checkPath.convert(originalPath);
-
-	    checkPath(
-	      path,
-	      originalPath,
-	      this._strictPathCheck
-	        ? throwError
-	        : RETURN_FALSE
-	    );
-
-	    return this._t(path, cache, checkUnignored, slices)
-	  }
-
-	  checkIgnore (path) {
-	    // If the path doest not end with a slash, `.ignores()` is much equivalent
-	    //   to `git check-ignore`
-	    if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
-	      return this.test(path)
-	    }
-
-	    const slices = path.split(SLASH).filter(Boolean);
-	    slices.pop();
-
-	    if (slices.length) {
-	      const parent = this._t(
-	        slices.join(SLASH) + SLASH,
-	        this._testCache,
-	        true,
-	        slices
-	      );
-
-	      if (parent.ignored) {
-	        return parent
-	      }
-	    }
-
-	    return this._rules.test(path, false, MODE_CHECK_IGNORE)
-	  }
-
-	  _t (
-	    // The path to be tested
-	    path,
-
-	    // The cache for the result of a certain checking
-	    cache,
-
-	    // Whether should check if the path is unignored
-	    checkUnignored,
-
-	    // The path slices
-	    slices
-	  ) {
-	    if (path in cache) {
-	      return cache[path]
-	    }
-
-	    if (!slices) {
-	      // path/to/a.js
-	      // ['path', 'to', 'a.js']
-	      slices = path.split(SLASH).filter(Boolean);
-	    }
-
-	    slices.pop();
-
-	    // If the path has no parent directory, just test it
-	    if (!slices.length) {
-	      return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE)
-	    }
-
-	    const parent = this._t(
-	      slices.join(SLASH) + SLASH,
-	      cache,
-	      checkUnignored,
-	      slices
-	    );
-
-	    // If the path contains a parent directory, check the parent first
-	    return cache[path] = parent.ignored
-	      // > It is not possible to re-include a file if a parent directory of
-	      // >   that file is excluded.
-	      ? parent
-	      : this._rules.test(path, checkUnignored, MODE_IGNORE)
-	  }
-
-	  ignores (path) {
-	    return this._test(path, this._ignoreCache, false).ignored
-	  }
-
-	  createFilter () {
-	    return path => !this.ignores(path)
-	  }
-
-	  filter (paths) {
-	    return makeArray(paths).filter(this.createFilter())
-	  }
-
-	  // @returns {TestResult}
-	  test (path) {
-	    return this._test(path, this._testCache, true)
-	  }
-	}
-
-	const factory = options => new Ignore(options);
-
-	const isPathValid = path =>
-	  checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
-
-	/* istanbul ignore next */
-	const setupWindows = () => {
-	  /* eslint no-control-regex: "off" */
-	  const makePosix = str => /^\\\\\?\\/.test(str)
-	  || /["<>|\u0000-\u001F]+/u.test(str)
-	    ? str
-	    : str.replace(/\\/g, '/');
-
-	  checkPath.convert = makePosix;
-
-	  // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
-	  // 'd:\\foo'
-	  const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-	  checkPath.isNotRelative = path =>
-	    REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path)
-	    || isNotRelative(path);
-	};
-
-	// COMMONJS_EXPORTS ////////////////////////////////////////////////////////////
-
-	module.exports = factory;
-
-	// Although it is an anti-pattern,
-	//   it is still widely misused by a lot of libraries in github
-	// Ref: https://github.com/search?q=ignore.default%28%29&type=code
-	factory.default = factory;
-
-	module.exports.isPathValid = isPathValid;
-
-	// For testing purposes
-	define(module.exports, Symbol.for('setupWindows'), setupWindows); 
-} (ignore$2));
-
-var ignoreExports = ignore$2.exports;
-ignoreExports.default;
-
 const {relative} = require$$0$1;
-const ignore$1 = ignoreExports;
+const ignore$1 = require$$1$1;
 
 const isNegative = (a) => !a.indexOf('!');
 const positive = (a) => a.replace(/^!/, '');