{"version":3,"sources":["webpack:///./node_modules/@babel/parser/lib/index.js"],"names":["_assertThisInitialized","_toConsumableArray","_slicedToArray","_get","_inherits","_possibleConstructorReturn","_getPrototypeOf","_createClass","_classCallCheck","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Date","prototype","toString","call","e","_isNativeReflectConstruct","result","Super","NewTarget","this","constructor","arguments","apply","Object","defineProperty","exports","value","TokenType","label","conf","length","undefined","keyword","beforeExpr","startsExpr","rightAssociative","isLoop","isAssign","prefix","postfix","binop","updateContext","keywords","Map","createKeyword","name","options","token","set","createBinop","types","num","bigint","decimal","regexp","string","eof","bracketL","bracketHashL","bracketBarL","bracketR","bracketBarR","braceL","braceBarL","braceHashL","braceR","braceBarR","parenL","parenR","comma","semi","colon","doubleColon","dot","question","questionDot","arrow","template","ellipsis","backQuote","dollarBraceL","at","hash","interpreterDirective","eq","assign","incDec","bang","tilde","pipeline","nullishCoalescing","logicalOR","logicalAND","bitwiseOR","bitwiseXOR","bitwiseAND","equality","relational","bitShift","plusMin","modulo","star","slash","exponent","_break","_case","_catch","_continue","_debugger","_default","_do","_else","_finally","_for","_function","_if","_return","_switch","_throw","_try","_var","_const","_while","_with","_new","_this","_super","_class","_extends","_export","_import","_null","_true","_false","_in","_instanceof","_typeof","_void","_delete","lineBreak","lineBreakG","RegExp","source","isNewLine","code","skipWhiteSpace","isWhitespace","Position","line","col","column","SourceLocation","start","end","last","stack","CommentsParser","_BaseParser","key","comment","filename","loc","state","trailingComments","push","leadingComments","node","elements","takeAllComments","lastElement","i","j","commentPreviousNode","splice","newTrailingComments","_i8","leadingComment","type","body","firstChild","lastChild","commentStack","lastInStack","pop","adjustCommentsAfterTrailingComma","properties","slice","innerComments","firstTrailingCommentIndex","findIndex","BaseParser","sawUnambiguousESM","ambiguousScriptDifferentAst","plugins","has","plugin","hasPlugin","get","ErrorMessages","freeze","AccessorIsGenerator","ArgumentsDisallowedInInitializer","AsyncFunctionInSingleStatementContext","AwaitBindingIdentifier","AwaitExpressionFormalParameter","AwaitNotInAsyncFunction","BadGetterArity","BadSetterArity","BadSetterRestParameter","ConstructorClassField","ConstructorClassPrivateField","ConstructorIsAccessor","ConstructorIsAsync","ConstructorIsGenerator","DeclarationMissingInitializer","DecoratorBeforeExport","DecoratorConstructor","DecoratorExportClass","DecoratorSemicolon","DeletePrivateField","DestructureNamedImport","DuplicateConstructor","DuplicateDefaultExport","DuplicateExport","DuplicateProto","DuplicateRegExpFlags","ElementAfterRest","EscapedCharNotAnIdentifier","ExportDefaultFromAsIdentifier","ForInOfLoopInitializer","GeneratorInSingleStatementContext","IllegalBreakContinue","IllegalLanguageModeDirective","IllegalReturn","ImportCallArgumentTrailingComma","ImportCallArity","ImportCallNotNewExpression","ImportCallSpreadArgument","ImportMetaOutsideModule","ImportOutsideModule","InvalidBigIntLiteral","InvalidCodePoint","InvalidDecimal","InvalidDigit","InvalidEscapeSequence","InvalidEscapeSequenceTemplate","InvalidEscapedReservedWord","InvalidIdentifier","InvalidLhs","InvalidLhsBinding","InvalidNumber","InvalidOrUnexpectedToken","InvalidParenthesizedAssignment","InvalidPrivateFieldResolution","InvalidPropertyBindingPattern","InvalidRecordProperty","InvalidRestAssignmentPattern","LabelRedeclaration","LetInLexicalBinding","LineTerminatorBeforeArrow","MalformedRegExpFlags","MissingClassName","MissingEqInAssignment","MissingUnicodeEscape","MixingCoalesceWithLogical","ModuleAttributeDifferentFromType","ModuleAttributeInvalidValue","ModuleAttributesWithDuplicateKeys","ModuleExportUndefined","MultipleDefaultsInSwitch","NewlineAfterThrow","NoCatchOrFinally","NumberIdentifier","NumericSeparatorInEscapeSequence","ObsoleteAwaitStar","OptionalChainingNoNew","OptionalChainingNoTemplate","ParamDupe","PatternHasAccessor","PatternHasMethod","PipelineBodyNoArrow","PipelineBodySequenceExpression","PipelineHeadSequenceExpression","PipelineTopicUnused","PrimaryTopicNotAllowed","PrimaryTopicRequiresSmartPipeline","PrivateInExpectedIn","PrivateNameRedeclaration","RecordExpressionBarIncorrectEndSyntaxType","RecordExpressionBarIncorrectStartSyntaxType","RecordExpressionHashIncorrectStartSyntaxType","RecordNoProto","RestTrailingComma","SloppyFunction","StaticPrototype","StrictDelete","StrictEvalArguments","StrictEvalArgumentsBinding","StrictFunction","StrictNumericEscape","StrictOctalLiteral","StrictWith","SuperNotAllowed","SuperPrivateField","TrailingDecorator","TupleExpressionBarIncorrectEndSyntaxType","TupleExpressionBarIncorrectStartSyntaxType","TupleExpressionHashIncorrectStartSyntaxType","UnexpectedArgumentPlaceholder","UnexpectedAwaitAfterPipelineBody","UnexpectedDigitAfterHash","UnexpectedImportExport","UnexpectedKeyword","UnexpectedLeadingDecorator","UnexpectedLexicalDeclaration","UnexpectedNewTarget","UnexpectedNumericSeparator","UnexpectedPrivateField","UnexpectedReservedWord","UnexpectedSuper","UnexpectedToken","UnexpectedTokenUnaryExponentiation","UnsupportedBind","UnsupportedDecoratorExport","UnsupportedDefaultExport","UnsupportedImport","UnsupportedMetaProperty","UnsupportedParameterDecorator","UnsupportedPropertyDecorator","UnsupportedSuper","UnterminatedComment","UnterminatedRegExp","UnterminatedString","UnterminatedTemplate","VarRedeclaration","YieldBindingIdentifier","YieldInParameter","ZeroDigitNumericSeparator","ParserError","_CommentsParser","_super2","pos","startLoc","lastTokStart","lastTokStartLoc","endLoc","lastTokEnd","lastTokEndLoc","input","offset","match","lineStart","lastIndex","exec","index","getLineInfo","errorTemplate","_len","params","Array","_key","raiseWithData","concat","data","_len2","_key2","getLocationForPosition","message","replace","_","_raise","errorContext","err","SyntaxError","errorRecovery","isLookahead","errors","isSimpleProperty","kind","method","TokContext","isExpr","preserveSpace","override","types$1","braceStatement","braceExpression","recordExpression","templateQuasi","parenStatement","parenExpression","p","readTmplToken","functionExpression","functionStatement","context","out","curContext","exprAllowed","prevType","allowed","prodParam","hasYield","isIterator","braceIsBlock","statementParens","hasPrecedingLineBreak","b_stat","nonASCIIidentifierStartChars","nonASCIIidentifierChars","nonASCIIidentifierStart","nonASCIIidentifier","astralIdentifierStartCodes","astralIdentifierCodes","isInAstralSet","isIdentifierStart","test","String","fromCharCode","isIdentifierChar","reservedWords","keywords$1","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","isStrictBindOnlyReservedWord","isStrictBindReservedWord","keywordRelationalOperator","reservedTypes","FlowErrors","AmbiguousConditionalArrow","AmbiguousDeclareModuleKind","AssignReservedType","DeclareClassElement","DeclareClassFieldInitializer","DuplicateDeclareModuleExports","EnumBooleanMemberNotInitialized","EnumDuplicateMemberName","EnumInconsistentMemberValues","EnumInvalidExplicitType","EnumInvalidExplicitTypeUnknownSupplied","EnumInvalidMemberInitializerPrimaryType","EnumInvalidMemberInitializerSymbolType","EnumInvalidMemberInitializerUnknownType","EnumInvalidMemberName","EnumNumberMemberNotInitialized","EnumStringMemberInconsistentlyInitailized","ImportTypeShorthandOnlyInPureImport","InexactInsideExact","InexactInsideNonObject","InexactVariance","InvalidNonTypeImportInDeclareModule","MissingTypeParamDefault","NestedDeclareModule","NestedFlowComment","OptionalBindingPattern","SpreadVariance","TypeBeforeInitializer","TypeCastInPattern","UnexpectedExplicitInexactInObject","UnexpectedReservedType","UnexpectedReservedUnderscore","UnexpectedSpaceBetweenModuloChecks","UnexpectedSpreadType","UnexpectedSubtractionOperand","UnexpectedTokenAfterTypeParameter","UnexpectedTypeParameterBeforeAsyncArrowFunction","UnsupportedDeclareExportKind","UnsupportedStatementInDeclareModule","UnterminatedFlowComment","hasTypeImportKind","importKind","isMaybeDefaultImport","exportSuggestions","const","let","interface","FLOW_PRAGMA_REGEX","entities","quot","amp","apos","lt","gt","nbsp","iexcl","cent","pound","curren","yen","brvbar","sect","uml","copy","ordf","laquo","not","shy","reg","macr","deg","plusmn","sup2","sup3","acute","micro","para","middot","cedil","sup1","ordm","raquo","frac14","frac12","frac34","iquest","Agrave","Aacute","Acirc","Atilde","Auml","Aring","AElig","Ccedil","Egrave","Eacute","Ecirc","Euml","Igrave","Iacute","Icirc","Iuml","ETH","Ntilde","Ograve","Oacute","Ocirc","Otilde","Ouml","times","Oslash","Ugrave","Uacute","Ucirc","Uuml","Yacute","THORN","szlig","agrave","aacute","acirc","atilde","auml","aring","aelig","ccedil","egrave","eacute","ecirc","euml","igrave","iacute","icirc","iuml","eth","ntilde","ograve","oacute","ocirc","otilde","ouml","divide","oslash","ugrave","uacute","ucirc","uuml","yacute","thorn","yuml","OElig","oelig","Scaron","scaron","Yuml","fnof","circ","Alpha","Beta","Gamma","Delta","Epsilon","Zeta","Eta","Theta","Iota","Kappa","Lambda","Mu","Nu","Xi","Omicron","Pi","Rho","Sigma","Tau","Upsilon","Phi","Chi","Psi","Omega","alpha","beta","gamma","delta","epsilon","zeta","eta","theta","iota","kappa","lambda","mu","nu","xi","omicron","pi","rho","sigmaf","sigma","tau","upsilon","phi","chi","psi","omega","thetasym","upsih","piv","ensp","emsp","thinsp","zwnj","zwj","lrm","rlm","ndash","mdash","lsquo","rsquo","sbquo","ldquo","rdquo","bdquo","dagger","Dagger","bull","hellip","permil","prime","Prime","lsaquo","rsaquo","oline","frasl","euro","image","weierp","real","trade","alefsym","larr","uarr","rarr","darr","harr","crarr","lArr","uArr","rArr","dArr","hArr","forall","part","exist","empty","nabla","isin","notin","ni","prod","sum","minus","lowast","radic","prop","infin","ang","and","or","cap","cup","int","there4","sim","cong","asymp","ne","equiv","le","ge","sub","sup","nsub","sube","supe","oplus","otimes","perp","sdot","lceil","rceil","lfloor","rfloor","lang","rang","loz","spades","clubs","hearts","diams","HEX_NUMBER","DECIMAL_NUMBER","JsxErrors","AttributeIsEmpty","MissingClosingTagFragment","MissingClosingTagElement","UnsupportedJsxValue","UnterminatedJsxContent","UnwrappedAdjacentJSXElements","isFragment","object","getQualifiedJSXName","namespace","property","Error","j_oTag","j_cTag","j_expr","jsxName","jsxText","jsxTagStart","jsxTagEnd","Scope","flags","var","lexical","functions","ScopeHandler","raise","scopeStack","undefinedExports","undefinedPrivateNames","createScope","scope","bindingType","currentScope","checkRedeclarationInScope","maybeExportDefined","SCOPE_PROGRAM","delete","isRedeclaredInScope","indexOf","treatFunctionsAsVarInScope","id","currentVarScope","currentThisScope","TypeScriptScope","_Scope","_super6","_this16","_len3","args","_key3","enums","constEnums","classes","exportOnlyBindings","TypeScriptScopeHandler","_ScopeHandler","_super7","isConst","wasConst","ProductionParameterHandler","stacks","currentFlags","functionFlags","isAsync","isGenerator","nonNull","x","assert","TSErrors","ClassMethodHasDeclare","ClassMethodHasReadonly","DeclareClassFieldHasInitializer","DuplicateModifier","EmptyHeritageClauseType","IndexSignatureHasAbstract","IndexSignatureHasAccessibility","IndexSignatureHasStatic","InvalidTupleMemberLabel","MixedLabeledAndUnlabeledElements","OptionalTypeBeforeRequired","PatternIsOptional","PrivateElementHasAbstract","PrivateElementHasAccessibility","TemplateTypeHasSubstitution","TypeAnnotationAfterAssign","UnexpectedReadonly","UnexpectedTypeAnnotation","UnexpectedTypeCastInParameter","UnsupportedImportTypeArgument","UnsupportedParameterPropertyKind","UnsupportedSignatureParameterKind","placeholder","some","isArray","getPluginOption","option","find","PIPELINE_PROPOSALS","RECORD_AND_TUPLE_SYNTAX_TYPES","mixinPlugins","estree","superClass","_superClass","_super3","_ref","pattern","regex","estreeParseLiteral","bigInt","BigInt","parseLiteral","directive","directiveLiteral","stmt","startNodeAt","expression","raw","extra","finishNodeAt","checkDeclaration","paramCount","expr","checkClashes","contextDescription","disallowLetBinding","forEach","checkLVal","isRecord","protoRef","refExpressionErrors","_stmt$expression$extr","parenthesized","allowDirectives","topLevel","_this2","directiveStatements","directives","map","d","directiveToStmt","classBody","isConstructor","allowsDirectSuper","parseMethod","typeParameters","estreeParseRegExpLiteral","estreeParseBigIntLiteral","estreeParseDecimalLiteral","startPos","allowExpression","isMethod","allowDirectSuper","inClassScope","funcNode","startNode","finishNode","isPattern","isAccessor","shorthand","toAssignable","isLast","optional","callee","exprList","isParenthesizedExpr","exported","specifiers","base","noCalls","optionalChainMember","substring","stop","chain","startNodeAtNode","jsx","_superClass3","_class3","_super5","chunkStart","ch","charCodeAt","finishToken","jsxReadEntity","jsxReadNewLine","normalizeCRLF","curLine","quote","entity","str","count","substr","fromCodePoint","parseInt","unexpected","next","jsxParseIdentifier","eat","jsxParseNamespacedName","newNode","jsxParseExpressionContainer","parseExprAtom","parseExpression","expect","jsxParseEmptyExpression","argument","parseMaybeAssignAllowIn","jsxParseAttributeValue","jsxParseElementName","jsxParseOpeningElementAfterName","attributes","jsxParseAttribute","selfClosing","children","openingElement","jsxParseOpeningElementAt","closingElement","contents","jsxParseClosingElementAt","jsxParseElementAt","_node5","jsxParseSpreadChild","openingFragment","closingFragment","isRelational","jsxParseElement","inPropertyName","jsxReadToken","jsxReadWord","jsxReadString","flow","_superClass2","_class2","_super4","_this3","flowPragma","val","matches","tok","oldInType","inType","flowParseType","moduloLoc","moduloPos","checksLoc","expectContextual","predicate","flowParsePredicate","flowParseInterfaceish","parseIdentifier","typeNode","typeContainer","flowParseTypeParameterDeclaration","tmp","flowParseFunctionTypeParams","rest","_this$flowParseTypeAn","flowParseTypeAndPredicateInitialiser","_this$flowParseTypeAn2","returnType","typeAnnotation","resetEndLocation","semicolon","insideModule","flowParseDeclareClass","flowParseDeclareFunction","flowParseDeclareVariable","eatContextual","flowParseDeclareModuleExports","flowParseDeclareModule","isContextual","flowParseDeclareTypeAlias","flowParseDeclareOpaqueType","flowParseDeclareInterface","flowParseDeclareExportDeclaration","flowParseTypeAnnotatableIdentifier","declareName","BIND_KIND_VALUE","_this4","enter","bodyNode","_bodyNode","parseImport","flowParseDeclare","exit","hasModuleExport","bodyElement","declaration","isEsModuleType","default","isLet","suggestion","parseExport","exportKind","flowParseTypeAnnotation","flowParseTypeAlias","flowParseOpaqueType","isClass","flowParseRestrictedIdentifier","extends","implements","mixins","flowParseInterfaceExtends","flowParseObjectType","allowStatic","allowExact","allowSpread","allowProto","allowInexact","flowParseQualifiedTypeIdentifier","flowParseTypeParameterInstantiation","liberal","checkReservedType","right","flowParseTypeInitialiser","declare","supertype","impltype","requireDefault","nodeStart","variance","flowParseVariance","ident","bound","defaultRequired","typeParameter","flowParseTypeParameter","expectRelational","oldNoAnonFunctionType","noAnonFunctionType","flowParseTypeOrImplicitInstantiation","isStatic","static","lookahead","flowParseObjectPropertyKey","flowParseObjectTypeMethodish","flowParseFunctionTypeParam","valueNode","_ref2","endDelim","exact","callProperties","indexers","internalSlots","inexact","protoStart","inexactStart","_lookahead","flowParseObjectTypeInternalSlot","flowParseObjectTypeIndexer","flowParseObjectTypeCallProperty","_lookahead2","propOrInexact","flowParseObjectTypeProperty","flowObjectTypeSemicolon","proto","flowCheckGetterSetterParams","node2","qualification","flowParsePrimaryType","lh","checkNotUnderscore","flowParseGenericType","isGroupedType","flowParseInterfaceType","flowIdentToTypeAnnotation","flowParseTupleType","reinterpretTypeAsFunctionTypeParam","flowParseTypeofType","canInsertSemicolon","elementType","flowParsePrefixType","flowParsePostfixType","param","flowParseAnonFunctionWithoutParens","flowParseIntersectionType","flowParseUnionType","allowPrimitiveOverride","allowExpressionBody","_this5","forwardNoArrowParamsConversionAt","_this$flowParseTypeAn3","_this$flowParseTypeAn4","strict","flowParseInterface","shouldParseEnums","_node","flowParseEnumDeclaration","isValidDirective","refNeedsArrowPos","_this6","tryParse","error","failState","clone","originalNoArrowAt","noArrowAt","_this$tryParseConditi","tryParseConditionalConsequent","consequent","failed","_this$getArrowLikeExp","getArrowLikeExpressions","_this$getArrowLikeExp2","valid","invalid","_this$tryParseConditi2","_this$getArrowLikeExp3","_this$getArrowLikeExp4","_this$tryParseConditi3","alternate","parseMaybeAssign","noArrowParamsConversionAt","disallowInvalid","_this7","arrows","_node2","finishArrowValidation","list","list1","list2","partition","every","isAssignable","_node$extra","toAssignableList","trailingComma","SCOPE_FUNCTION","parse","typeCastNode","decl","declarationNode","parseExportSpecifiers","parseExportFrom","_declarationNode","_declarationNode2","_declarationNode3","hasNamespace","isStatement","optionalId","member","constructorAllowsSuper","parseClassMemberFromModifier","finishOp","current","isIteratorStart","isBinding","_this8","_last","element","operator","typeCastToParameter","trailingCommaPos","_expr$extra","superTypeParameters","implemented","_node3","isPrivateNameAllowed","left","specifier","local","firstIdentLoc","firstIdent","specifierTypeKind","isLookaheadContextual","as_ident","imported","__clone","nodeIsTypeImport","specifierIsTypeImport","checkReservedWord","allowModifiers","afterLeftParse","_jsx","_this9","_jsx2","_jsx3","abort","_arrowExpression$extr","arrowExpression","resetStartLocationFromNode","maybeUnwrapTypeCastExpression","aborted","async","thrown","_this10","_this10$flowParseType","_this10$flowParseType2","allowDuplicates","isArrowFunction","canBeArrow","_this11","parseCallExpressionArguments","parseAsyncArrowWithTypeParameters","subscriptState","_this12","isLookaheadToken_lt","typeArguments","finishCallExpression","shouldParseTypes","_node4","flowParseTypeParameterInstantiationCallOrNew","_this13","targs","parseFunctionParams","parseArrow","parseArrowExpression","hasFlowComment","nextToken","file","program","fileNode","skipFlowComment","hasFlowCommentCompletion","shiftToFirstNonWhiteSpace","includes","ch2","ch3","_ref3","enumName","memberName","_ref4","toUpperCase","_ref5","_ref6","_ref7","suppliedType","_ref8","explicitType","_ref9","_ref10","_this14","endOfInit","literal","_literal","_literal2","parseBooleanLiteral","init","flowEnumMemberInit","expectedType","flowEnumErrorInvalidMemberInitializer","_ref11","seenNames","members","booleanMembers","numberMembers","stringMembers","defaultedMembers","memberNode","_this$flowEnumMemberR","flowEnumMemberRaw","flowEnumErrorInvalidMemberName","flowEnumErrorDuplicateMemberName","add","flowEnumCheckExplicitTypeMismatch","flowEnumErrorBooleanMemberNotInitialized","flowEnumErrorNumberMemberNotInitialized","initializedMembers","_ref12","_i","flowEnumErrorStringMemberInconsistentlyInitailized","_i2","_member","_ref13","flowEnumErrorInvalidExplicitType","_ref14","_this15","nameLoc","flowEnumParseExplicitType","flowEnumMembers","flowEnumStringMembers","boolsLen","numsLen","strsLen","defaultedLen","_i3","_members$defaultedMem","_i4","_members$defaultedMem2","_member2","flowEnumErrorInconsistentMemberValues","flowEnumBody","nextTokenStart","afterNext","typescript","_superClass4","_class4","_super8","allowedModifiers","modifier","tsTryParse","tsNextTokenCanFollowModifier","bind","modified","tsParseModifier","hasOwnProperty","parseElement","tsIsListTerminator","tsParseDelimitedListWorker","expectSuccess","bracket","skipFirstToken","tsParseDelimitedList","qualifier","tsParseEntityName","tsParseTypeArguments","allowReservedWords","typeName","lhs","parameterName","tsParseTypeAnnotation","exprName","tsParseImportType","parseIdentifierName","constraint","tsEatThenParseType","tsParseTypeParameters","tsParseBracketedList","tsParseTypeParameter","tsParseTypeReference","returnToken","signature","returnTokenRequired","tsTryParseTypeParameters","parameters","tsParseBindingListForSignature","tsParseTypeOrTypePredicateAnnotation","_this17","parseBindingList","tsFillSignature","tsParseTypeMemberSemicolon","tsLookAhead","tsIsUnambiguouslyIndexSignature","tsTryParseTypeAnnotation","readonly","nodeAny","tsParseSignatureMember","createIdentifier","tsParsePropertyOrMethodSignature","idx","tsTryParseIndexSignature","parsePropertyName","tsParseObjectTypeMembers","tsParseList","tsParseTypeMember","tsIsIdentifier","tsExpectThenParseType","tsParseMappedTypeParameter","tsTryParseType","_this18","elementTypes","tsParseTupleElementType","seenOptionalElement","labeledElements","elementNode","_labeledElements","isLabeled","_this$state","tsParseType","labeledNode","optionalTypeNode","restNode","_this19","templateNode","parseTemplate","expressions","thisKeyword","tsParseThisTypeNode","tsParseThisTypePredicate","keywordTypeFromName","lookaheadCharCode","tsParseLiteralTypeNode","_node6","parseMaybeUnary","tsParseThisTypeOrThisTypePredicate","tsParseTypeQuery","tsIsStartOfMappedType","tsParseMappedType","tsParseTypeLiteral","tsParseTupleType","tsParseParenthesizedType","tsParseTemplateLiteralType","tsParseNonArrayType","_node7","objectType","indexType","tsParseTypeOperatorOrHigher","tsCheckTypeAnnotationForReadOnly","_this20","kw","tsParseTypeOperator","tsParseInferType","tsParseArrayTypeOrHigher","parseConstituentType","_types","tsParseUnionOrIntersectionType","tsParseIntersectionTypeOrHigher","tsIsUnambiguouslyStartOfFunctionType","braceStackCounter","_braceStackCounter","tsSkipParameterStart","_this21","tsInType","t","asserts","tsParseTypePredicateAsserts","thisTypePredicate","_node8","typePredicateVariable","tsParseTypePredicatePrefix","_node9","containsEsc","_this22","eatColon","tsParseNonConditionalType","checkType","extendsType","trueType","falseType","tsIsStartOfFunctionType","tsParseFunctionOrConstructorType","tsParseUnionTypeOrHigher","tsTryNextParseConstantContext","tsNextThenParseType","descriptor","originalStart","delimitedList","tsParseExpressionWithTypeArguments","tsParseHeritageClause","cb","oldContext","_this23","tsDoThenParseType","_this24","_this25","initializer","BIND_TS_ENUM","tsParseEnumMember","parseBlockOrModuleBlockBody","nested","inner","tsParseModuleOrNamespaceDeclaration","tsParseModuleBlock","global","isExport","moduleReference","tsParseModuleReference","tsIsExternalModuleReference","tsParseExternalModuleReference","f","res","nany","isLineTerminator","starttype","parseFunctionStatement","parseClass","tsParseEnumDeclaration","parseVarStatement","tsParseAmbientExternalModuleDeclaration","tsParseDeclaration","tsTryParseDeclare","mod","tsCheckLineTerminatorAndMatch","cls","abstract","tsParseInterfaceDeclaration","tsParseTypeAliasDeclaration","tokenType","_this26","oldMaybeInArrowParameters","maybeInArrowParameters","oldYieldPos","yieldPos","oldAwaitPos","awaitPos","tsTryParseAndCatch","tsTryParseTypeOrTypePredicateAnnotation","_this27","tsInNoContext","tsIsDeclarationStart","decorators","accessibility","parseAccessModifier","parseMaybeDefault","parseAssignableListItemTypes","elt","pp","parameter","bodilessType","_this28","nonNullExpression","atPossibleAsyncArrow","asyncArrowFn","tsTryParseGenericAsyncArrowFunction","_result","parseTaggedTemplateExpression","_this29","leftStartPos","leftStartLoc","minPrec","reScan_lt_gt","parseExprOp","checkKeywords","ahead","tsParseImportEqualsDeclaration","importNode","isAbstractClass","tsParseModifiers","methodOrProp","tsParseExpressionStatement","_this30","isDeclare","tsTryParseExportDeclaration","resetStartLocation","definite","parseClassPropertyAnnotation","equal","_get2","_len4","_key4","_typeCast","_typeCast2","_jsx4","_typeCast3","typeCast","_get4","_this31","_len5","_key5","_get3","_get5","_typeParameters","_get6","tsParseTypeAssertion","_this32","_get7","_len6","_key6","readToken_lt_gt","isInParens","_this33","baseCount","firstParam","v8intrinsic","_superClass6","_class6","_super10","v8IntrinsicStart","identifier","parseV8Intrinsic","placeholders","_superClass5","_class5","_super9","expectedNode","assertNoSpace","finishPlaceholder","isFinished","parsePlaceholder","parseStatement","takeDecorators","oldStrict","parseClassId","parseClassSuper","parseClassBody","expectPlugin","isUnparsedContextual","startsWith","nextTokenStartSince","filter","hasStarImport","maybeParseStarImportSpecifier","parseNamedImportSpecifiers","parseImportSource","mixinPluginNames","keys","defaultOptions","sourceType","sourceFilename","startLine","allowAwaitOutsideFunction","allowReturnOutsideFunction","allowImportExportEverywhere","allowSuperOutsideMethod","allowUndeclaredExports","strictMode","ranges","tokens","createParenthesizedExpressions","State","potentialArrowAt","inParameters","maybeInAsyncArrowHead","inPipeline","topicContext","maxNumOfResolvableTopics","maxTopicIndex","soloAwait","inFSharpPipelineDirectBody","labels","decoratorStack","comments","octalPositions","exportedIdentifiers","tokensLength","curPosition","skipArrays","_isDigit","VALID_REGEX_FLAGS","forbiddenNumericSeparatorSiblings","decBinOct","hex","allowedNumericSeparatorSiblings","oct","bin","dec","Token","UtilParser","_Tokenizer","_super12","op","nameStart","nameEnd","messageOrType","missingPlugin","names","_this35","n","join","fn","oldState","abortSignal","_failState","andThrow","shorthandAssign","doubleProto","_ParserError","Tokenizer","_super11","_this34","checkKeywordEscapes","pushToken","old","curr","lastIndexOf","skipSpace","getTokenFromCode","codePointAt","block","text","addComment","pushComment","startSkip","loop","skipBlockComment","skipLineComment","readToken_interpreter","nextPos","readNumber","readRegexp","width","size","next2","readToken_dot","readToken_question","readRadixNumber","readString","readToken_slash","readToken_mult_modulo","readToken_pipe_amp","readToken_caret","readToken_plus_min","readToken_eq_excl","readToken_numberSign","readWord","escaped","inClass","charAt","content","mods","char","charCode","radix","len","forceLen","allowNumSeparator","forbiddenSiblings","allowedSiblings","total","Infinity","prev","Number","isNaN","isBigInt","readInt","startsWithDot","isFloat","isDecimal","hasExponent","isOctal","hasLeadingZero","integer","underscorePos","parseFloat","throwOnInvalid","codePos","readHexChar","readEscapedChar","containsInvalid","inTemplate","_code","readCodePoint","octalStr","octal","escStart","identifierCheck","esc","readWord1","parent","update","ExpressionErrors","Node","parser","range","loopLabel","switchLabel","StatementParser","_ExpressionParser","_super16","interpreter","parseInterpreterDirective","parseBlockBody","_Array$from","from","addExtra","nextCh","parseDecorators","parseStatementContent","parseBreakContinueStatement","parseDebuggerStatement","parseDoStatement","parseForStatement","parseIfStatement","parseReturnStatement","parseSwitchStatement","parseThrowStatement","parseTryStatement","parseWhileStatement","parseWithStatement","parseBlock","parseEmptyStatement","nextTokenCharCode","assertModuleNodeAllowed","isAsyncFunction","maybeName","parseLabeledStatement","parseExpressionStatement","allowExport","currentContextDecorators","decorator","parseDecorator","canHaveLeadingDecorator","expectOnePlugin","_node11","computed","parseMaybeDecoratorArguments","parseExprSubscripts","toReferencedList","isBreak","verifyBreakContinue","lab","_this41","withTopicForbiddingContext","parseHeaderExpression","awaitAt","isAwaitAllowed","parseFor","_init","parseVar","declarations","parseForIn","description","checkExpressionErrors","declarationPosition","parseFunction","hasReturn","discriminant","cur","sawDefault","cases","isCase","parseBindingAtom","simple","_this42","handler","clause","parseCatchClauseParam","finalizer","_this43","_this44","_this$state$labels","_label","statementStart","createNewLexicalScope","afterBlockParse","hasStrictModeDirective","parsedNonDirective","stmtToDirective","setStrict","_this45","_this46","isForIn","await","isFor","isTypescript","parseVarId","parseMaybeAssignDisallowIn","_this47","statement","isHangingStatement","requireId","initFunction","generator","parseFunctionId","parseFunctionBodyAndFinish","registerFunctionStatementId","oldInParameters","checkYieldAwaitInDefaultParams","treatFunctionsAsVar","_this48","classScope","hadConstructor","parseClassMember","isClassMethod","pushClassMethod","isClassProperty","parseClassProperty","parseClassMemberWithIsStatic","publicMethod","privateMethod","publicProp","privateProp","publicMember","parseClassElementName","pushClassPrivateMethod","isNonstaticConstructor","isPrivate","isSimple","maybeQuestionTokenStart","parsePostMemberNameModifiers","pushClassPrivateProperty","pushClassProperty","checkGetterSetterParams","parseClassPrivateProperty","declarePrivateName","CLASS_ELEMENT_KIND_GETTER","CLASS_ELEMENT_KIND_SETTER","SCOPE_CLASS","hasDefault","maybeParseExportDefaultSpecifier","parseAfterDefault","hasStar","eatExportStar","maybeParseExportNamespaceSpecifier","parseAfterNamespace","isFromRequired","hasDeclaration","hasSpecifiers","maybeParseExportNamedSpecifiers","maybeParseExportDeclaration","checkExport","parseExportDefaultExpression","isExportDefaultSpecifier","_node$specifiers2","shouldParseExportDeclaration","parseExportDeclaration","FUNC_STATEMENT","l","hasFrom","nextAfterFrom","checkNames","isDefault","isFrom","checkDuplicateExports","_declaration$extra","_node$specifiers","checkLocalExport","_i5","_node$declaration$dec","_declaration","_i6","_node$properties","_i7","_node$elements","elem","nodes","first","parseNext","maybeParseDefaultImportSpecifier","maybeParseModuleAttributes","attrs","shouldParseDefaultImport","parseImportSpecifierLocal","parseImportSpecifier","_LValParser","ExpressionParser","_super15","used","paramFlags","disallowIn","_this36","disallowInAnd","parseExpressionBase","allowInAnd","_this37","_this38","ownExpressionErrors","_left2","parseYield","parseMaybeConditional","parseExprOps","shouldExitDescending","parseConditional","prec","hasIn","checkPipelineAtInfixOperator","logical","coalesce","hasAwait","parseExprOpRightExpr","nextOp","_this39","withTopicPermittingContext","parseSmartPipelineBody","parseExprOpBaseRightExpr","withSoloAwaitPermittingContext","parseFSharpPipelineBody","parseAwait","isDelete","arg","parseUpdate","_node10","parseSubscripts","maybeAsyncArrow","oldMaybeInAsyncArrowHead","parseSubscript","parseBind","parseCoverCallAndAsyncArrowHead","parseMember","parseMaybePrivateName","usePrivateName","parseNoCallExpr","shouldParseAsyncArrow","parseAsyncArrowFromCallExpression","toReferencedListDeep","tag","quasi","_node$arguments","close","possibleAsyncArrow","dynamicImport","allowPlaceholder","nodeForExtra","innerParenStart","elts","oldInFSharpPipelineDirectBody","parseExprListItem","_call$extra","parseSuper","parseImportMetaProperty","_last4","parseAsyncArrowUnaryFunction","parseDo","parseParenAndDistinguishExpression","parseArrayLike","parseObjectLike","parseFunctionOrFunctionSent","parseNewOrNewTarget","primaryTopicReferenceIsAllowedInCurrentTopicContext","registerTopicReference","lookaheadCh","oldLabels","allowSuper","meta","parseMetaProperty","propertyName","spreadStart","optionalCommaStart","innerStartPos","innerStartLoc","spreadNodeStartPos","spreadNodeStartLoc","parseParenItem","parseRestBinding","checkCommaAfterRest","innerEndPos","innerEndLoc","arrowNode","shouldParseArrow","parenStart","metaProp","inNonArrowFunction","parseNew","parseNewArguments","parseExprList","isTagged","cooked","tail","curElt","parseTemplateElement","quasis","propHash","create","parsePropertyDefinition","checkProto","isLiteralPropertyName","parseSpread","maybeAsyncOrAccessorProp","keyName","parseObjPropValue","getGetterSetterExpectedParamCount","parseObjectMethod","parseObjectProperty","oldInPropertyName","canBePattern","isTuple","setArrowFunctionParameters","parseFunctionBody","_this40","isExpression","checkParams","nonSimple","isSimpleParamList","errorPos","strictModeChanged","nameHash","allowEmpty","identifierName","_this$state2","isKeyword","inFunction","delegate","childExpression","checkSmartPipelineBodyEarlyErrors","parseSmartPipelineBodyInStyle","isSimpleReference","topicReferenceWasUsedInCurrentTopicContext","callback","outerContextTopicState","outerContextSoloAwaitState","ret","_NodeUtils","LValParser","_super14","_node$extra3","unwrapParenthesizedExpression","_last2","_node$extra2","toAssignableObjectExpressionProp","raiseRestNotLast","checkToRestConversion","_last3","raiseTrailingCommaAfterRest","closeCharCode","parseAssignableListItem","_startLoc","_startPos","_left","_expr$properties","_expr$elements","_UtilParser","NodeUtils","_super13","processComment","locationNode","ClassScope","privateNames","loneAccessors","ClassScopeHandler","oldClassScope","_Array$from$_i2","redefined","accessor","_this$stack","Parser","_StatementParser","_super17","_this49","opts","_Object$keys","getOptions","getScopeHandler","pluginMap","_ref15","_ref16","pluginsMap","parseTopLevel","getParser","decoratorsBeforeExport","validatePlugins","pluginsFromOptions","pluginList","parserClassCache","getParserClass","_options","ast","_unused","moduleError","_unused2","getExpression","tokTypes"],"mappings":"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,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,GAAI,EAAG,EAAG,GAAI,GAAI,GAAI,EAAG,EAAG,GAAI,IAAK,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,GAAI,EAAG,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,IAAK,GAAI,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,IAAK,GAAI,IAAK,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,GAAI,GAAI,IAAK,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,EAAG,IAAK,GAAI,IAAK,EAAG,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,KAAM,IAAK,KAAM,IAAK,EAAG,GAAI,IAAK,GAAI,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,EAAG,GAAI,IAAK,GAAI,IAAK,GAAI,EAAG,EAAG,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,KAAM,EAAG,KAAM,GAAI,EAAG,KAAM,IAAK,GAAI,EAAG,GAAI,EAAG,EAAG,IAAK,KAAM,IAAK,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,KAAM,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAAK,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,KAAM,GAAI,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,KAAM,IAAK,GAAI,GAAI,EAAG,EAAG,KAAM,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,KAAM,MAAO,GAAI,KAAM,GAAI,IAAK,EAAG,KAAM,GAAI,KAAM,KAAM,IAAK,KAAM,MAC3wDC,EAAwB,CAAC,IAAK,EAAG,IAAK,EAAG,IAAK,EAAG,IAAK,EAAG,KAAM,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,IAAK,EAAG,IAAK,EAAG,EAAG,EAAG,IAAK,EAAG,IAAK,GAAI,IAAK,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,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","file":"d57d79ab-6afe2a8fdb916dc10916.js","sourcesContent":["'use strict';\n\nvar _assertThisInitialized = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/assertThisInitialized\");\n\nvar _toConsumableArray = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/toConsumableArray\");\n\nvar _slicedToArray = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/slicedToArray\");\n\nvar _get = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/get\");\n\nvar _inherits = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/getPrototypeOf\");\n\nvar _createClass = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/createClass\");\n\nvar _classCallCheck = require(\"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/classCallCheck\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar beforeExpr = true;\nvar startsExpr = true;\nvar isLoop = true;\nvar isAssign = true;\nvar prefix = true;\nvar postfix = true;\n\nvar TokenType = function TokenType(label) {\n  var conf = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  _classCallCheck(this, TokenType);\n\n  this.label = label;\n  this.keyword = conf.keyword;\n  this.beforeExpr = !!conf.beforeExpr;\n  this.startsExpr = !!conf.startsExpr;\n  this.rightAssociative = !!conf.rightAssociative;\n  this.isLoop = !!conf.isLoop;\n  this.isAssign = !!conf.isAssign;\n  this.prefix = !!conf.prefix;\n  this.postfix = !!conf.postfix;\n  this.binop = conf.binop != null ? conf.binop : null;\n  this.updateContext = null;\n};\n\nvar keywords = new Map();\n\nfunction createKeyword(name) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  options.keyword = name;\n  var token = new TokenType(name, options);\n  keywords.set(name, token);\n  return token;\n}\n\nfunction createBinop(name, binop) {\n  return new TokenType(name, {\n    beforeExpr: beforeExpr,\n    binop: binop\n  });\n}\n\nvar types = {\n  num: new TokenType(\"num\", {\n    startsExpr: startsExpr\n  }),\n  bigint: new TokenType(\"bigint\", {\n    startsExpr: startsExpr\n  }),\n  decimal: new TokenType(\"decimal\", {\n    startsExpr: startsExpr\n  }),\n  regexp: new TokenType(\"regexp\", {\n    startsExpr: startsExpr\n  }),\n  string: new TokenType(\"string\", {\n    startsExpr: startsExpr\n  }),\n  name: new TokenType(\"name\", {\n    startsExpr: startsExpr\n  }),\n  eof: new TokenType(\"eof\"),\n  bracketL: new TokenType(\"[\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  bracketHashL: new TokenType(\"#[\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  bracketBarL: new TokenType(\"[|\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  bracketR: new TokenType(\"]\"),\n  bracketBarR: new TokenType(\"|]\"),\n  braceL: new TokenType(\"{\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  braceBarL: new TokenType(\"{|\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  braceHashL: new TokenType(\"#{\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  braceR: new TokenType(\"}\"),\n  braceBarR: new TokenType(\"|}\"),\n  parenL: new TokenType(\"(\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  parenR: new TokenType(\")\"),\n  comma: new TokenType(\",\", {\n    beforeExpr: beforeExpr\n  }),\n  semi: new TokenType(\";\", {\n    beforeExpr: beforeExpr\n  }),\n  colon: new TokenType(\":\", {\n    beforeExpr: beforeExpr\n  }),\n  doubleColon: new TokenType(\"::\", {\n    beforeExpr: beforeExpr\n  }),\n  dot: new TokenType(\".\"),\n  question: new TokenType(\"?\", {\n    beforeExpr: beforeExpr\n  }),\n  questionDot: new TokenType(\"?.\"),\n  arrow: new TokenType(\"=>\", {\n    beforeExpr: beforeExpr\n  }),\n  template: new TokenType(\"template\"),\n  ellipsis: new TokenType(\"...\", {\n    beforeExpr: beforeExpr\n  }),\n  backQuote: new TokenType(\"`\", {\n    startsExpr: startsExpr\n  }),\n  dollarBraceL: new TokenType(\"${\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  at: new TokenType(\"@\"),\n  hash: new TokenType(\"#\", {\n    startsExpr: startsExpr\n  }),\n  interpreterDirective: new TokenType(\"#!...\"),\n  eq: new TokenType(\"=\", {\n    beforeExpr: beforeExpr,\n    isAssign: isAssign\n  }),\n  assign: new TokenType(\"_=\", {\n    beforeExpr: beforeExpr,\n    isAssign: isAssign\n  }),\n  incDec: new TokenType(\"++/--\", {\n    prefix: prefix,\n    postfix: postfix,\n    startsExpr: startsExpr\n  }),\n  bang: new TokenType(\"!\", {\n    beforeExpr: beforeExpr,\n    prefix: prefix,\n    startsExpr: startsExpr\n  }),\n  tilde: new TokenType(\"~\", {\n    beforeExpr: beforeExpr,\n    prefix: prefix,\n    startsExpr: startsExpr\n  }),\n  pipeline: createBinop(\"|>\", 0),\n  nullishCoalescing: createBinop(\"??\", 1),\n  logicalOR: createBinop(\"||\", 1),\n  logicalAND: createBinop(\"&&\", 2),\n  bitwiseOR: createBinop(\"|\", 3),\n  bitwiseXOR: createBinop(\"^\", 4),\n  bitwiseAND: createBinop(\"&\", 5),\n  equality: createBinop(\"==/!=/===/!==\", 6),\n  relational: createBinop(\"</>/<=/>=\", 7),\n  bitShift: createBinop(\"<</>>/>>>\", 8),\n  plusMin: new TokenType(\"+/-\", {\n    beforeExpr: beforeExpr,\n    binop: 9,\n    prefix: prefix,\n    startsExpr: startsExpr\n  }),\n  modulo: new TokenType(\"%\", {\n    beforeExpr: beforeExpr,\n    binop: 10,\n    startsExpr: startsExpr\n  }),\n  star: new TokenType(\"*\", {\n    binop: 10\n  }),\n  slash: createBinop(\"/\", 10),\n  exponent: new TokenType(\"**\", {\n    beforeExpr: beforeExpr,\n    binop: 11,\n    rightAssociative: true\n  }),\n  _break: createKeyword(\"break\"),\n  _case: createKeyword(\"case\", {\n    beforeExpr: beforeExpr\n  }),\n  _catch: createKeyword(\"catch\"),\n  _continue: createKeyword(\"continue\"),\n  _debugger: createKeyword(\"debugger\"),\n  _default: createKeyword(\"default\", {\n    beforeExpr: beforeExpr\n  }),\n  _do: createKeyword(\"do\", {\n    isLoop: isLoop,\n    beforeExpr: beforeExpr\n  }),\n  _else: createKeyword(\"else\", {\n    beforeExpr: beforeExpr\n  }),\n  _finally: createKeyword(\"finally\"),\n  _for: createKeyword(\"for\", {\n    isLoop: isLoop\n  }),\n  _function: createKeyword(\"function\", {\n    startsExpr: startsExpr\n  }),\n  _if: createKeyword(\"if\"),\n  _return: createKeyword(\"return\", {\n    beforeExpr: beforeExpr\n  }),\n  _switch: createKeyword(\"switch\"),\n  _throw: createKeyword(\"throw\", {\n    beforeExpr: beforeExpr,\n    prefix: prefix,\n    startsExpr: startsExpr\n  }),\n  _try: createKeyword(\"try\"),\n  _var: createKeyword(\"var\"),\n  _const: createKeyword(\"const\"),\n  _while: createKeyword(\"while\", {\n    isLoop: isLoop\n  }),\n  _with: createKeyword(\"with\"),\n  _new: createKeyword(\"new\", {\n    beforeExpr: beforeExpr,\n    startsExpr: startsExpr\n  }),\n  _this: createKeyword(\"this\", {\n    startsExpr: startsExpr\n  }),\n  _super: createKeyword(\"super\", {\n    startsExpr: startsExpr\n  }),\n  _class: createKeyword(\"class\", {\n    startsExpr: startsExpr\n  }),\n  _extends: createKeyword(\"extends\", {\n    beforeExpr: beforeExpr\n  }),\n  _export: createKeyword(\"export\"),\n  _import: createKeyword(\"import\", {\n    startsExpr: startsExpr\n  }),\n  _null: createKeyword(\"null\", {\n    startsExpr: startsExpr\n  }),\n  _true: createKeyword(\"true\", {\n    startsExpr: startsExpr\n  }),\n  _false: createKeyword(\"false\", {\n    startsExpr: startsExpr\n  }),\n  _in: createKeyword(\"in\", {\n    beforeExpr: beforeExpr,\n    binop: 7\n  }),\n  _instanceof: createKeyword(\"instanceof\", {\n    beforeExpr: beforeExpr,\n    binop: 7\n  }),\n  _typeof: createKeyword(\"typeof\", {\n    beforeExpr: beforeExpr,\n    prefix: prefix,\n    startsExpr: startsExpr\n  }),\n  _void: createKeyword(\"void\", {\n    beforeExpr: beforeExpr,\n    prefix: prefix,\n    startsExpr: startsExpr\n  }),\n  _delete: createKeyword(\"delete\", {\n    beforeExpr: beforeExpr,\n    prefix: prefix,\n    startsExpr: startsExpr\n  })\n};\nvar SCOPE_OTHER = 0,\n    SCOPE_PROGRAM = 1,\n    SCOPE_FUNCTION = 2,\n    SCOPE_ARROW = 4,\n    SCOPE_SIMPLE_CATCH = 8,\n    SCOPE_SUPER = 16,\n    SCOPE_DIRECT_SUPER = 32,\n    SCOPE_CLASS = 64,\n    SCOPE_TS_MODULE = 128,\n    SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE;\nvar BIND_KIND_VALUE = 1,\n    BIND_KIND_TYPE = 2,\n    BIND_SCOPE_VAR = 4,\n    BIND_SCOPE_LEXICAL = 8,\n    BIND_SCOPE_FUNCTION = 16,\n    BIND_FLAGS_NONE = 64,\n    BIND_FLAGS_CLASS = 128,\n    BIND_FLAGS_TS_ENUM = 256,\n    BIND_FLAGS_TS_CONST_ENUM = 512,\n    BIND_FLAGS_TS_EXPORT_ONLY = 1024;\nvar BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS,\n    BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0,\n    BIND_VAR = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0,\n    BIND_FUNCTION = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0,\n    BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS,\n    BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0,\n    BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM,\n    BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,\n    BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE,\n    BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE,\n    BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM,\n    BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY;\nvar CLASS_ELEMENT_FLAG_STATIC = 4,\n    CLASS_ELEMENT_KIND_GETTER = 2,\n    CLASS_ELEMENT_KIND_SETTER = 1,\n    CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;\nvar CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC,\n    CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC,\n    CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER,\n    CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER,\n    CLASS_ELEMENT_OTHER = 0;\nvar lineBreak = /\\r\\n?|[\\n\\u2028\\u2029]/;\nvar lineBreakG = new RegExp(lineBreak.source, \"g\");\n\nfunction isNewLine(code) {\n  switch (code) {\n    case 10:\n    case 13:\n    case 8232:\n    case 8233:\n      return true;\n\n    default:\n      return false;\n  }\n}\n\nvar skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\n\nfunction isWhitespace(code) {\n  switch (code) {\n    case 0x0009:\n    case 0x000b:\n    case 0x000c:\n    case 32:\n    case 160:\n    case 5760:\n    case 0x2000:\n    case 0x2001:\n    case 0x2002:\n    case 0x2003:\n    case 0x2004:\n    case 0x2005:\n    case 0x2006:\n    case 0x2007:\n    case 0x2008:\n    case 0x2009:\n    case 0x200a:\n    case 0x202f:\n    case 0x205f:\n    case 0x3000:\n    case 0xfeff:\n      return true;\n\n    default:\n      return false;\n  }\n}\n\nvar Position = function Position(line, col) {\n  _classCallCheck(this, Position);\n\n  this.line = line;\n  this.column = col;\n};\n\nvar SourceLocation = function SourceLocation(start, end) {\n  _classCallCheck(this, SourceLocation);\n\n  this.start = start;\n  this.end = end;\n};\n\nfunction getLineInfo(input, offset) {\n  var line = 1;\n  var lineStart = 0;\n  var match;\n  lineBreakG.lastIndex = 0;\n\n  while ((match = lineBreakG.exec(input)) && match.index < offset) {\n    line++;\n    lineStart = lineBreakG.lastIndex;\n  }\n\n  return new Position(line, offset - lineStart);\n}\n\nvar BaseParser = /*#__PURE__*/function () {\n  function BaseParser() {\n    _classCallCheck(this, BaseParser);\n\n    this.sawUnambiguousESM = false;\n    this.ambiguousScriptDifferentAst = false;\n  }\n\n  _createClass(BaseParser, [{\n    key: \"hasPlugin\",\n    value: function hasPlugin(name) {\n      return this.plugins.has(name);\n    }\n  }, {\n    key: \"getPluginOption\",\n    value: function getPluginOption(plugin, name) {\n      if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];\n    }\n  }]);\n\n  return BaseParser;\n}();\n\nfunction last(stack) {\n  return stack[stack.length - 1];\n}\n\nvar CommentsParser = /*#__PURE__*/function (_BaseParser) {\n  _inherits(CommentsParser, _BaseParser);\n\n  var _super = _createSuper(CommentsParser);\n\n  function CommentsParser() {\n    _classCallCheck(this, CommentsParser);\n\n    return _super.apply(this, arguments);\n  }\n\n  _createClass(CommentsParser, [{\n    key: \"addComment\",\n    value: function addComment(comment) {\n      if (this.filename) comment.loc.filename = this.filename;\n      this.state.trailingComments.push(comment);\n      this.state.leadingComments.push(comment);\n    }\n  }, {\n    key: \"adjustCommentsAfterTrailingComma\",\n    value: function adjustCommentsAfterTrailingComma(node, elements, takeAllComments) {\n      if (this.state.leadingComments.length === 0) {\n        return;\n      }\n\n      var lastElement = null;\n      var i = elements.length;\n\n      while (lastElement === null && i > 0) {\n        lastElement = elements[--i];\n      }\n\n      if (lastElement === null) {\n        return;\n      }\n\n      for (var j = 0; j < this.state.leadingComments.length; j++) {\n        if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {\n          this.state.leadingComments.splice(j, 1);\n          j--;\n        }\n      }\n\n      var newTrailingComments = [];\n\n      for (var _i8 = 0; _i8 < this.state.leadingComments.length; _i8++) {\n        var leadingComment = this.state.leadingComments[_i8];\n\n        if (leadingComment.end < node.end) {\n          newTrailingComments.push(leadingComment);\n\n          if (!takeAllComments) {\n            this.state.leadingComments.splice(_i8, 1);\n            _i8--;\n          }\n        } else {\n          if (node.trailingComments === undefined) {\n            node.trailingComments = [];\n          }\n\n          node.trailingComments.push(leadingComment);\n        }\n      }\n\n      if (takeAllComments) this.state.leadingComments = [];\n\n      if (newTrailingComments.length > 0) {\n        lastElement.trailingComments = newTrailingComments;\n      } else if (lastElement.trailingComments !== undefined) {\n        lastElement.trailingComments = [];\n      }\n    }\n  }, {\n    key: \"processComment\",\n    value: function processComment(node) {\n      if (node.type === \"Program\" && node.body.length > 0) return;\n      var stack = this.state.commentStack;\n      var firstChild, lastChild, trailingComments, i, j;\n\n      if (this.state.trailingComments.length > 0) {\n        if (this.state.trailingComments[0].start >= node.end) {\n          trailingComments = this.state.trailingComments;\n          this.state.trailingComments = [];\n        } else {\n          this.state.trailingComments.length = 0;\n        }\n      } else if (stack.length > 0) {\n        var lastInStack = last(stack);\n\n        if (lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {\n          trailingComments = lastInStack.trailingComments;\n          delete lastInStack.trailingComments;\n        }\n      }\n\n      if (stack.length > 0 && last(stack).start >= node.start) {\n        firstChild = stack.pop();\n      }\n\n      while (stack.length > 0 && last(stack).start >= node.start) {\n        lastChild = stack.pop();\n      }\n\n      if (!lastChild && firstChild) lastChild = firstChild;\n\n      if (firstChild) {\n        switch (node.type) {\n          case \"ObjectExpression\":\n            this.adjustCommentsAfterTrailingComma(node, node.properties);\n            break;\n\n          case \"ObjectPattern\":\n            this.adjustCommentsAfterTrailingComma(node, node.properties, true);\n            break;\n\n          case \"CallExpression\":\n            this.adjustCommentsAfterTrailingComma(node, node.arguments);\n            break;\n\n          case \"ArrayExpression\":\n            this.adjustCommentsAfterTrailingComma(node, node.elements);\n            break;\n\n          case \"ArrayPattern\":\n            this.adjustCommentsAfterTrailingComma(node, node.elements, true);\n            break;\n        }\n      } else if (this.state.commentPreviousNode && (this.state.commentPreviousNode.type === \"ImportSpecifier\" && node.type !== \"ImportSpecifier\" || this.state.commentPreviousNode.type === \"ExportSpecifier\" && node.type !== \"ExportSpecifier\")) {\n        this.adjustCommentsAfterTrailingComma(node, [this.state.commentPreviousNode]);\n      }\n\n      if (lastChild) {\n        if (lastChild.leadingComments) {\n          if (lastChild !== node && lastChild.leadingComments.length > 0 && last(lastChild.leadingComments).end <= node.start) {\n            node.leadingComments = lastChild.leadingComments;\n            delete lastChild.leadingComments;\n          } else {\n            for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {\n              if (lastChild.leadingComments[i].end <= node.start) {\n                node.leadingComments = lastChild.leadingComments.splice(0, i + 1);\n                break;\n              }\n            }\n          }\n        }\n      } else if (this.state.leadingComments.length > 0) {\n        if (last(this.state.leadingComments).end <= node.start) {\n          if (this.state.commentPreviousNode) {\n            for (j = 0; j < this.state.leadingComments.length; j++) {\n              if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {\n                this.state.leadingComments.splice(j, 1);\n                j--;\n              }\n            }\n          }\n\n          if (this.state.leadingComments.length > 0) {\n            node.leadingComments = this.state.leadingComments;\n            this.state.leadingComments = [];\n          }\n        } else {\n          for (i = 0; i < this.state.leadingComments.length; i++) {\n            if (this.state.leadingComments[i].end > node.start) {\n              break;\n            }\n          }\n\n          var leadingComments = this.state.leadingComments.slice(0, i);\n\n          if (leadingComments.length) {\n            node.leadingComments = leadingComments;\n          }\n\n          trailingComments = this.state.leadingComments.slice(i);\n\n          if (trailingComments.length === 0) {\n            trailingComments = null;\n          }\n        }\n      }\n\n      this.state.commentPreviousNode = node;\n\n      if (trailingComments) {\n        if (trailingComments.length && trailingComments[0].start >= node.start && last(trailingComments).end <= node.end) {\n          node.innerComments = trailingComments;\n        } else {\n          var firstTrailingCommentIndex = trailingComments.findIndex(function (comment) {\n            return comment.end >= node.end;\n          });\n\n          if (firstTrailingCommentIndex > 0) {\n            node.innerComments = trailingComments.slice(0, firstTrailingCommentIndex);\n            node.trailingComments = trailingComments.slice(firstTrailingCommentIndex);\n          } else {\n            node.trailingComments = trailingComments;\n          }\n        }\n      }\n\n      stack.push(node);\n    }\n  }]);\n\n  return CommentsParser;\n}(BaseParser);\n\nvar ErrorMessages = Object.freeze({\n  AccessorIsGenerator: \"A %0ter cannot be a generator\",\n  ArgumentsDisallowedInInitializer: \"'arguments' is not allowed in class field initializer\",\n  AsyncFunctionInSingleStatementContext: \"Async functions can only be declared at the top level or inside a block\",\n  AwaitBindingIdentifier: \"Can not use 'await' as identifier inside an async function\",\n  AwaitExpressionFormalParameter: \"await is not allowed in async function parameters\",\n  AwaitNotInAsyncFunction: \"Can not use keyword 'await' outside an async function\",\n  BadGetterArity: \"getter must not have any formal parameters\",\n  BadSetterArity: \"setter must have exactly one formal parameter\",\n  BadSetterRestParameter: \"setter function argument must not be a rest parameter\",\n  ConstructorClassField: \"Classes may not have a field named 'constructor'\",\n  ConstructorClassPrivateField: \"Classes may not have a private field named '#constructor'\",\n  ConstructorIsAccessor: \"Class constructor may not be an accessor\",\n  ConstructorIsAsync: \"Constructor can't be an async function\",\n  ConstructorIsGenerator: \"Constructor can't be a generator\",\n  DeclarationMissingInitializer: \"%0 require an initialization value\",\n  DecoratorBeforeExport: \"Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax\",\n  DecoratorConstructor: \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n  DecoratorExportClass: \"Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.\",\n  DecoratorSemicolon: \"Decorators must not be followed by a semicolon\",\n  DeletePrivateField: \"Deleting a private field is not allowed\",\n  DestructureNamedImport: \"ES2015 named imports do not destructure. Use another statement for destructuring after the import.\",\n  DuplicateConstructor: \"Duplicate constructor in the same class\",\n  DuplicateDefaultExport: \"Only one default export allowed per module.\",\n  DuplicateExport: \"`%0` has already been exported. Exported identifiers must be unique.\",\n  DuplicateProto: \"Redefinition of __proto__ property\",\n  DuplicateRegExpFlags: \"Duplicate regular expression flag\",\n  ElementAfterRest: \"Rest element must be last element\",\n  EscapedCharNotAnIdentifier: \"Invalid Unicode escape\",\n  ExportDefaultFromAsIdentifier: \"'from' is not allowed as an identifier after 'export default'\",\n  ForInOfLoopInitializer: \"%0 loop variable declaration may not have an initializer\",\n  GeneratorInSingleStatementContext: \"Generators can only be declared at the top level or inside a block\",\n  IllegalBreakContinue: \"Unsyntactic %0\",\n  IllegalLanguageModeDirective: \"Illegal 'use strict' directive in function with non-simple parameter list\",\n  IllegalReturn: \"'return' outside of function\",\n  ImportCallArgumentTrailingComma: \"Trailing comma is disallowed inside import(...) arguments\",\n  ImportCallArity: \"import() requires exactly %0\",\n  ImportCallNotNewExpression: \"Cannot use new with import(...)\",\n  ImportCallSpreadArgument: \"... is not allowed in import()\",\n  ImportMetaOutsideModule: \"import.meta may appear only with 'sourceType: \\\"module\\\"'\",\n  ImportOutsideModule: \"'import' and 'export' may appear only with 'sourceType: \\\"module\\\"'\",\n  InvalidBigIntLiteral: \"Invalid BigIntLiteral\",\n  InvalidCodePoint: \"Code point out of bounds\",\n  InvalidDecimal: \"Invalid decimal\",\n  InvalidDigit: \"Expected number in radix %0\",\n  InvalidEscapeSequence: \"Bad character escape sequence\",\n  InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template\",\n  InvalidEscapedReservedWord: \"Escape sequence in keyword %0\",\n  InvalidIdentifier: \"Invalid identifier %0\",\n  InvalidLhs: \"Invalid left-hand side in %0\",\n  InvalidLhsBinding: \"Binding invalid left-hand side in %0\",\n  InvalidNumber: \"Invalid number\",\n  InvalidOrUnexpectedToken: \"Unexpected character '%0'\",\n  InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern\",\n  InvalidPrivateFieldResolution: \"Private name #%0 is not defined\",\n  InvalidPropertyBindingPattern: \"Binding member expression\",\n  InvalidRecordProperty: \"Only properties and spread elements are allowed in record definitions\",\n  InvalidRestAssignmentPattern: \"Invalid rest operator's argument\",\n  LabelRedeclaration: \"Label '%0' is already declared\",\n  LetInLexicalBinding: \"'let' is not allowed to be used as a name in 'let' or 'const' declarations.\",\n  LineTerminatorBeforeArrow: \"No line break is allowed before '=>'\",\n  MalformedRegExpFlags: \"Invalid regular expression flag\",\n  MissingClassName: \"A class name is required\",\n  MissingEqInAssignment: \"Only '=' operator can be used for specifying default value.\",\n  MissingUnicodeEscape: \"Expecting Unicode escape sequence \\\\uXXXX\",\n  MixingCoalesceWithLogical: \"Nullish coalescing operator(??) requires parens when mixing with logical operators\",\n  ModuleAttributeDifferentFromType: \"The only accepted module attribute is `type`\",\n  ModuleAttributeInvalidValue: \"Only string literals are allowed as module attribute values\",\n  ModuleAttributesWithDuplicateKeys: 'Duplicate key \"%0\" is not allowed in module attributes',\n  ModuleExportUndefined: \"Export '%0' is not defined\",\n  MultipleDefaultsInSwitch: \"Multiple default clauses\",\n  NewlineAfterThrow: \"Illegal newline after throw\",\n  NoCatchOrFinally: \"Missing catch or finally clause\",\n  NumberIdentifier: \"Identifier directly after number\",\n  NumericSeparatorInEscapeSequence: \"Numeric separators are not allowed inside unicode escape sequences or hex escape sequences\",\n  ObsoleteAwaitStar: \"await* has been removed from the async functions proposal. Use Promise.all() instead.\",\n  OptionalChainingNoNew: \"constructors in/after an Optional Chain are not allowed\",\n  OptionalChainingNoTemplate: \"Tagged Template Literals are not allowed in optionalChain\",\n  ParamDupe: \"Argument name clash\",\n  PatternHasAccessor: \"Object pattern can't contain getter or setter\",\n  PatternHasMethod: \"Object pattern can't contain methods\",\n  PipelineBodyNoArrow: 'Unexpected arrow \"=>\" after pipeline body; arrow function in pipeline body must be parenthesized',\n  PipelineBodySequenceExpression: \"Pipeline body may not be a comma-separated sequence expression\",\n  PipelineHeadSequenceExpression: \"Pipeline head should not be a comma-separated sequence expression\",\n  PipelineTopicUnused: \"Pipeline is in topic style but does not use topic reference\",\n  PrimaryTopicNotAllowed: \"Topic reference was used in a lexical context without topic binding\",\n  PrimaryTopicRequiresSmartPipeline: \"Primary Topic Reference found but pipelineOperator not passed 'smart' for 'proposal' option.\",\n  PrivateInExpectedIn: \"Private names are only allowed in property accesses (`obj.#%0`) or in `in` expressions (`#%0 in obj`)\",\n  PrivateNameRedeclaration: \"Duplicate private name #%0\",\n  RecordExpressionBarIncorrectEndSyntaxType: \"Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'\",\n  RecordExpressionBarIncorrectStartSyntaxType: \"Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'\",\n  RecordExpressionHashIncorrectStartSyntaxType: \"Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'\",\n  RecordNoProto: \"'__proto__' is not allowed in Record expressions\",\n  RestTrailingComma: \"Unexpected trailing comma after rest element\",\n  SloppyFunction: \"In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement\",\n  StaticPrototype: \"Classes may not have static property named prototype\",\n  StrictDelete: \"Deleting local variable in strict mode\",\n  StrictEvalArguments: \"Assigning to '%0' in strict mode\",\n  StrictEvalArgumentsBinding: \"Binding '%0' in strict mode\",\n  StrictFunction: \"In strict mode code, functions can only be declared at top level or inside a block\",\n  StrictNumericEscape: \"The only valid numeric escape in strict mode is '\\\\0'\",\n  StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode\",\n  StrictWith: \"'with' in strict mode\",\n  SuperNotAllowed: \"super() is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?\",\n  SuperPrivateField: \"Private fields can't be accessed on super\",\n  TrailingDecorator: \"Decorators must be attached to a class element\",\n  TupleExpressionBarIncorrectEndSyntaxType: \"Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'\",\n  TupleExpressionBarIncorrectStartSyntaxType: \"Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'\",\n  TupleExpressionHashIncorrectStartSyntaxType: \"Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'\",\n  UnexpectedArgumentPlaceholder: \"Unexpected argument placeholder\",\n  UnexpectedAwaitAfterPipelineBody: 'Unexpected \"await\" after pipeline body; await must have parentheses in minimal proposal',\n  UnexpectedDigitAfterHash: \"Unexpected digit after hash token\",\n  UnexpectedImportExport: \"'import' and 'export' may only appear at the top level\",\n  UnexpectedKeyword: \"Unexpected keyword '%0'\",\n  UnexpectedLeadingDecorator: \"Leading decorators must be attached to a class declaration\",\n  UnexpectedLexicalDeclaration: \"Lexical declaration cannot appear in a single-statement context\",\n  UnexpectedNewTarget: \"new.target can only be used in functions\",\n  UnexpectedNumericSeparator: \"A numeric separator is only allowed between two digits\",\n  UnexpectedPrivateField: \"Private names can only be used as the name of a class element (i.e. class C { #p = 42; #m() {} } )\\n or a property of member expression (i.e. this.#p).\",\n  UnexpectedReservedWord: \"Unexpected reserved word '%0'\",\n  UnexpectedSuper: \"super is only allowed in object methods and classes\",\n  UnexpectedToken: \"Unexpected token '%0'\",\n  UnexpectedTokenUnaryExponentiation: \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n  UnsupportedBind: \"Binding should be performed on object property.\",\n  UnsupportedDecoratorExport: \"A decorated export must export a class declaration\",\n  UnsupportedDefaultExport: \"Only expressions, functions or classes are allowed as the `default` export.\",\n  UnsupportedImport: \"import can only be used in import() or import.meta\",\n  UnsupportedMetaProperty: \"The only valid meta property for %0 is %0.%1\",\n  UnsupportedParameterDecorator: \"Decorators cannot be used to decorate parameters\",\n  UnsupportedPropertyDecorator: \"Decorators cannot be used to decorate object literal properties\",\n  UnsupportedSuper: \"super can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop])\",\n  UnterminatedComment: \"Unterminated comment\",\n  UnterminatedRegExp: \"Unterminated regular expression\",\n  UnterminatedString: \"Unterminated string constant\",\n  UnterminatedTemplate: \"Unterminated template\",\n  VarRedeclaration: \"Identifier '%0' has already been declared\",\n  YieldBindingIdentifier: \"Can not use 'yield' as identifier inside a generator\",\n  YieldInParameter: \"yield is not allowed in generator parameters\",\n  ZeroDigitNumericSeparator: \"Numeric separator can not be used after leading 0\"\n});\n\nvar ParserError = /*#__PURE__*/function (_CommentsParser) {\n  _inherits(ParserError, _CommentsParser);\n\n  var _super2 = _createSuper(ParserError);\n\n  function ParserError() {\n    _classCallCheck(this, ParserError);\n\n    return _super2.apply(this, arguments);\n  }\n\n  _createClass(ParserError, [{\n    key: \"getLocationForPosition\",\n    value: function getLocationForPosition(pos) {\n      var loc;\n      if (pos === this.state.start) loc = this.state.startLoc;else if (pos === this.state.lastTokStart) loc = this.state.lastTokStartLoc;else if (pos === this.state.end) loc = this.state.endLoc;else if (pos === this.state.lastTokEnd) loc = this.state.lastTokEndLoc;else loc = getLineInfo(this.input, pos);\n      return loc;\n    }\n  }, {\n    key: \"raise\",\n    value: function raise(pos, errorTemplate) {\n      for (var _len = arguments.length, params = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n        params[_key - 2] = arguments[_key];\n      }\n\n      return this.raiseWithData.apply(this, [pos, undefined, errorTemplate].concat(params));\n    }\n  }, {\n    key: \"raiseWithData\",\n    value: function raiseWithData(pos, data, errorTemplate) {\n      for (var _len2 = arguments.length, params = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {\n        params[_key2 - 3] = arguments[_key2];\n      }\n\n      var loc = this.getLocationForPosition(pos);\n      var message = errorTemplate.replace(/%(\\d+)/g, function (_, i) {\n        return params[i];\n      }) + \" (\".concat(loc.line, \":\").concat(loc.column, \")\");\n      return this._raise(Object.assign({\n        loc: loc,\n        pos: pos\n      }, data), message);\n    }\n  }, {\n    key: \"_raise\",\n    value: function _raise(errorContext, message) {\n      var err = new SyntaxError(message);\n      Object.assign(err, errorContext);\n\n      if (this.options.errorRecovery) {\n        if (!this.isLookahead) this.state.errors.push(err);\n        return err;\n      } else {\n        throw err;\n      }\n    }\n  }]);\n\n  return ParserError;\n}(CommentsParser);\n\nfunction isSimpleProperty(node) {\n  return node != null && node.type === \"Property\" && node.kind === \"init\" && node.method === false;\n}\n\nvar estree = function estree(superClass) {\n  return /*#__PURE__*/function (_superClass) {\n    _inherits(_class, _superClass);\n\n    var _super3 = _createSuper(_class);\n\n    function _class() {\n      _classCallCheck(this, _class);\n\n      return _super3.apply(this, arguments);\n    }\n\n    _createClass(_class, [{\n      key: \"estreeParseRegExpLiteral\",\n      value: function estreeParseRegExpLiteral(_ref) {\n        var pattern = _ref.pattern,\n            flags = _ref.flags;\n        var regex = null;\n\n        try {\n          regex = new RegExp(pattern, flags);\n        } catch (e) {}\n\n        var node = this.estreeParseLiteral(regex);\n        node.regex = {\n          pattern: pattern,\n          flags: flags\n        };\n        return node;\n      }\n    }, {\n      key: \"estreeParseBigIntLiteral\",\n      value: function estreeParseBigIntLiteral(value) {\n        var bigInt = typeof BigInt !== \"undefined\" ? BigInt(value) : null;\n        var node = this.estreeParseLiteral(bigInt);\n        node.bigint = String(node.value || value);\n        return node;\n      }\n    }, {\n      key: \"estreeParseDecimalLiteral\",\n      value: function estreeParseDecimalLiteral(value) {\n        var decimal = null;\n        var node = this.estreeParseLiteral(decimal);\n        node.decimal = String(node.value || value);\n        return node;\n      }\n    }, {\n      key: \"estreeParseLiteral\",\n      value: function estreeParseLiteral(value) {\n        return this.parseLiteral(value, \"Literal\");\n      }\n    }, {\n      key: \"directiveToStmt\",\n      value: function directiveToStmt(directive) {\n        var directiveLiteral = directive.value;\n        var stmt = this.startNodeAt(directive.start, directive.loc.start);\n        var expression = this.startNodeAt(directiveLiteral.start, directiveLiteral.loc.start);\n        expression.value = directiveLiteral.value;\n        expression.raw = directiveLiteral.extra.raw;\n        stmt.expression = this.finishNodeAt(expression, \"Literal\", directiveLiteral.end, directiveLiteral.loc.end);\n        stmt.directive = directiveLiteral.extra.raw.slice(1, -1);\n        return this.finishNodeAt(stmt, \"ExpressionStatement\", directive.end, directive.loc.end);\n      }\n    }, {\n      key: \"initFunction\",\n      value: function initFunction(node, isAsync) {\n        _get(_getPrototypeOf(_class.prototype), \"initFunction\", this).call(this, node, isAsync);\n\n        node.expression = false;\n      }\n    }, {\n      key: \"checkDeclaration\",\n      value: function checkDeclaration(node) {\n        if (isSimpleProperty(node)) {\n          this.checkDeclaration(node.value);\n        } else {\n          _get(_getPrototypeOf(_class.prototype), \"checkDeclaration\", this).call(this, node);\n        }\n      }\n    }, {\n      key: \"checkGetterSetterParams\",\n      value: function checkGetterSetterParams(method) {\n        var prop = method;\n        var paramCount = prop.kind === \"get\" ? 0 : 1;\n        var start = prop.start;\n\n        if (prop.value.params.length !== paramCount) {\n          if (method.kind === \"get\") {\n            this.raise(start, ErrorMessages.BadGetterArity);\n          } else {\n            this.raise(start, ErrorMessages.BadSetterArity);\n          }\n        } else if (prop.kind === \"set\" && prop.value.params[0].type === \"RestElement\") {\n          this.raise(start, ErrorMessages.BadSetterRestParameter);\n        }\n      }\n    }, {\n      key: \"checkLVal\",\n      value: function checkLVal(expr) {\n        var _this = this;\n\n        var bindingType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : BIND_NONE;\n        var checkClashes = arguments.length > 2 ? arguments[2] : undefined;\n        var contextDescription = arguments.length > 3 ? arguments[3] : undefined;\n        var disallowLetBinding = arguments.length > 4 ? arguments[4] : undefined;\n\n        switch (expr.type) {\n          case \"ObjectPattern\":\n            expr.properties.forEach(function (prop) {\n              _this.checkLVal(prop.type === \"Property\" ? prop.value : prop, bindingType, checkClashes, \"object destructuring pattern\", disallowLetBinding);\n            });\n            break;\n\n          default:\n            _get(_getPrototypeOf(_class.prototype), \"checkLVal\", this).call(this, expr, bindingType, checkClashes, contextDescription, disallowLetBinding);\n\n        }\n      }\n    }, {\n      key: \"checkProto\",\n      value: function checkProto(prop, isRecord, protoRef, refExpressionErrors) {\n        if (prop.method) {\n          return;\n        }\n\n        _get(_getPrototypeOf(_class.prototype), \"checkProto\", this).call(this, prop, isRecord, protoRef, refExpressionErrors);\n      }\n    }, {\n      key: \"isValidDirective\",\n      value: function isValidDirective(stmt) {\n        var _stmt$expression$extr;\n\n        return stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"Literal\" && typeof stmt.expression.value === \"string\" && !((_stmt$expression$extr = stmt.expression.extra) == null ? void 0 : _stmt$expression$extr.parenthesized);\n      }\n    }, {\n      key: \"stmtToDirective\",\n      value: function stmtToDirective(stmt) {\n        var directive = _get(_getPrototypeOf(_class.prototype), \"stmtToDirective\", this).call(this, stmt);\n\n        var value = stmt.expression.value;\n        directive.value.value = value;\n        return directive;\n      }\n    }, {\n      key: \"parseBlockBody\",\n      value: function parseBlockBody(node, allowDirectives, topLevel, end) {\n        var _this2 = this;\n\n        _get(_getPrototypeOf(_class.prototype), \"parseBlockBody\", this).call(this, node, allowDirectives, topLevel, end);\n\n        var directiveStatements = node.directives.map(function (d) {\n          return _this2.directiveToStmt(d);\n        });\n        node.body = directiveStatements.concat(node.body);\n        delete node.directives;\n      }\n    }, {\n      key: \"pushClassMethod\",\n      value: function pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n        this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, \"ClassMethod\", true);\n\n        if (method.typeParameters) {\n          method.value.typeParameters = method.typeParameters;\n          delete method.typeParameters;\n        }\n\n        classBody.body.push(method);\n      }\n    }, {\n      key: \"parseExprAtom\",\n      value: function parseExprAtom(refExpressionErrors) {\n        switch (this.state.type) {\n          case types.num:\n          case types.string:\n            return this.estreeParseLiteral(this.state.value);\n\n          case types.regexp:\n            return this.estreeParseRegExpLiteral(this.state.value);\n\n          case types.bigint:\n            return this.estreeParseBigIntLiteral(this.state.value);\n\n          case types.decimal:\n            return this.estreeParseDecimalLiteral(this.state.value);\n\n          case types._null:\n            return this.estreeParseLiteral(null);\n\n          case types._true:\n            return this.estreeParseLiteral(true);\n\n          case types._false:\n            return this.estreeParseLiteral(false);\n\n          default:\n            return _get(_getPrototypeOf(_class.prototype), \"parseExprAtom\", this).call(this, refExpressionErrors);\n        }\n      }\n    }, {\n      key: \"parseLiteral\",\n      value: function parseLiteral(value, type, startPos, startLoc) {\n        var node = _get(_getPrototypeOf(_class.prototype), \"parseLiteral\", this).call(this, value, type, startPos, startLoc);\n\n        node.raw = node.extra.raw;\n        delete node.extra;\n        return node;\n      }\n    }, {\n      key: \"parseFunctionBody\",\n      value: function parseFunctionBody(node, allowExpression) {\n        var isMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n        _get(_getPrototypeOf(_class.prototype), \"parseFunctionBody\", this).call(this, node, allowExpression, isMethod);\n\n        node.expression = node.body.type !== \"BlockStatement\";\n      }\n    }, {\n      key: \"parseMethod\",\n      value: function parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type) {\n        var inClassScope = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;\n        var funcNode = this.startNode();\n        funcNode.kind = node.kind;\n        funcNode = _get(_getPrototypeOf(_class.prototype), \"parseMethod\", this).call(this, funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);\n        funcNode.type = \"FunctionExpression\";\n        delete funcNode.kind;\n        node.value = funcNode;\n        type = type === \"ClassMethod\" ? \"MethodDefinition\" : type;\n        return this.finishNode(node, type);\n      }\n    }, {\n      key: \"parseObjectMethod\",\n      value: function parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {\n        var node = _get(_getPrototypeOf(_class.prototype), \"parseObjectMethod\", this).call(this, prop, isGenerator, isAsync, isPattern, isAccessor);\n\n        if (node) {\n          node.type = \"Property\";\n          if (node.kind === \"method\") node.kind = \"init\";\n          node.shorthand = false;\n        }\n\n        return node;\n      }\n    }, {\n      key: \"parseObjectProperty\",\n      value: function parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {\n        var node = _get(_getPrototypeOf(_class.prototype), \"parseObjectProperty\", this).call(this, prop, startPos, startLoc, isPattern, refExpressionErrors);\n\n        if (node) {\n          node.kind = \"init\";\n          node.type = \"Property\";\n        }\n\n        return node;\n      }\n    }, {\n      key: \"toAssignable\",\n      value: function toAssignable(node) {\n        if (isSimpleProperty(node)) {\n          this.toAssignable(node.value);\n          return node;\n        }\n\n        return _get(_getPrototypeOf(_class.prototype), \"toAssignable\", this).call(this, node);\n      }\n    }, {\n      key: \"toAssignableObjectExpressionProp\",\n      value: function toAssignableObjectExpressionProp(prop, isLast) {\n        if (prop.kind === \"get\" || prop.kind === \"set\") {\n          throw this.raise(prop.key.start, ErrorMessages.PatternHasAccessor);\n        } else if (prop.method) {\n          throw this.raise(prop.key.start, ErrorMessages.PatternHasMethod);\n        } else {\n          _get(_getPrototypeOf(_class.prototype), \"toAssignableObjectExpressionProp\", this).call(this, prop, isLast);\n        }\n      }\n    }, {\n      key: \"finishCallExpression\",\n      value: function finishCallExpression(node, optional) {\n        _get(_getPrototypeOf(_class.prototype), \"finishCallExpression\", this).call(this, node, optional);\n\n        if (node.callee.type === \"Import\") {\n          node.type = \"ImportExpression\";\n          node.source = node.arguments[0];\n          delete node.arguments;\n          delete node.callee;\n        }\n\n        return node;\n      }\n    }, {\n      key: \"toReferencedListDeep\",\n      value: function toReferencedListDeep(exprList, isParenthesizedExpr) {\n        if (!exprList) {\n          return;\n        }\n\n        _get(_getPrototypeOf(_class.prototype), \"toReferencedListDeep\", this).call(this, exprList, isParenthesizedExpr);\n      }\n    }, {\n      key: \"parseExport\",\n      value: function parseExport(node) {\n        _get(_getPrototypeOf(_class.prototype), \"parseExport\", this).call(this, node);\n\n        switch (node.type) {\n          case \"ExportAllDeclaration\":\n            node.exported = null;\n            break;\n\n          case \"ExportNamedDeclaration\":\n            if (node.specifiers.length === 1 && node.specifiers[0].type === \"ExportNamespaceSpecifier\") {\n              node.type = \"ExportAllDeclaration\";\n              node.exported = node.specifiers[0].exported;\n              delete node.specifiers;\n            }\n\n            break;\n        }\n\n        return node;\n      }\n    }, {\n      key: \"parseSubscript\",\n      value: function parseSubscript(base, startPos, startLoc, noCalls, state) {\n        var node = _get(_getPrototypeOf(_class.prototype), \"parseSubscript\", this).call(this, base, startPos, startLoc, noCalls, state);\n\n        if (state.optionalChainMember) {\n          if (node.type === \"OptionalMemberExpression\" || node.type === \"OptionalCallExpression\") {\n            node.type = node.type.substring(8);\n          }\n\n          if (state.stop) {\n            var chain = this.startNodeAtNode(node);\n            chain.expression = node;\n            return this.finishNode(chain, \"ChainExpression\");\n          }\n        } else if (node.type === \"MemberExpression\" || node.type === \"CallExpression\") {\n          node.optional = false;\n        }\n\n        return node;\n      }\n    }]);\n\n    return _class;\n  }(superClass);\n};\n\nvar TokContext = function TokContext(token, isExpr, preserveSpace, override) {\n  _classCallCheck(this, TokContext);\n\n  this.token = token;\n  this.isExpr = !!isExpr;\n  this.preserveSpace = !!preserveSpace;\n  this.override = override;\n};\n\nvar types$1 = {\n  braceStatement: new TokContext(\"{\", false),\n  braceExpression: new TokContext(\"{\", true),\n  recordExpression: new TokContext(\"#{\", true),\n  templateQuasi: new TokContext(\"${\", false),\n  parenStatement: new TokContext(\"(\", false),\n  parenExpression: new TokContext(\"(\", true),\n  template: new TokContext(\"`\", true, true, function (p) {\n    return p.readTmplToken();\n  }),\n  functionExpression: new TokContext(\"function\", true),\n  functionStatement: new TokContext(\"function\", false)\n};\n\ntypes.parenR.updateContext = types.braceR.updateContext = function () {\n  if (this.state.context.length === 1) {\n    this.state.exprAllowed = true;\n    return;\n  }\n\n  var out = this.state.context.pop();\n\n  if (out === types$1.braceStatement && this.curContext().token === \"function\") {\n    out = this.state.context.pop();\n  }\n\n  this.state.exprAllowed = !out.isExpr;\n};\n\ntypes.name.updateContext = function (prevType) {\n  var allowed = false;\n\n  if (prevType !== types.dot) {\n    if (this.state.value === \"of\" && !this.state.exprAllowed && prevType !== types._function && prevType !== types._class || this.state.value === \"yield\" && this.prodParam.hasYield) {\n      allowed = true;\n    }\n  }\n\n  this.state.exprAllowed = allowed;\n\n  if (this.state.isIterator) {\n    this.state.isIterator = false;\n  }\n};\n\ntypes.braceL.updateContext = function (prevType) {\n  this.state.context.push(this.braceIsBlock(prevType) ? types$1.braceStatement : types$1.braceExpression);\n  this.state.exprAllowed = true;\n};\n\ntypes.dollarBraceL.updateContext = function () {\n  this.state.context.push(types$1.templateQuasi);\n  this.state.exprAllowed = true;\n};\n\ntypes.parenL.updateContext = function (prevType) {\n  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;\n  this.state.context.push(statementParens ? types$1.parenStatement : types$1.parenExpression);\n  this.state.exprAllowed = true;\n};\n\ntypes.incDec.updateContext = function () {};\n\ntypes._function.updateContext = types._class.updateContext = function (prevType) {\n  if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else && !(prevType === types._return && this.hasPrecedingLineBreak()) && !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat)) {\n    this.state.context.push(types$1.functionExpression);\n  } else {\n    this.state.context.push(types$1.functionStatement);\n  }\n\n  this.state.exprAllowed = false;\n};\n\ntypes.backQuote.updateContext = function () {\n  if (this.curContext() === types$1.template) {\n    this.state.context.pop();\n  } else {\n    this.state.context.push(types$1.template);\n  }\n\n  this.state.exprAllowed = false;\n};\n\ntypes.braceHashL.updateContext = function () {\n  this.state.context.push(types$1.recordExpression);\n  this.state.exprAllowed = true;\n};\n\nvar nonASCIIidentifierStartChars = \"\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086A\\u08A0-\\u08B4\\u08B6-\\u08C7\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u09FC\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D04-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1878\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1CE9-\\u1CEC\\u1CEE-\\u1CF3\\u1CF5\\u1CF6\\u1CFA\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312F\\u3131-\\u318E\\u31A0-\\u31BF\\u31F0-\\u31FF\\u3400-\\u4DBF\\u4E00-\\u9FFC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7BF\\uA7C2-\\uA7CA\\uA7F5-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA8FE\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB69\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC\";\nvar nonASCIIidentifierChars = \"\\u200C\\u200D\\xB7\\u0300-\\u036F\\u0387\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u0669\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u06F0-\\u06F9\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07C0-\\u07C9\\u07EB-\\u07F3\\u07FD\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D3-\\u08E1\\u08E3-\\u0903\\u093A-\\u093C\\u093E-\\u094F\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096F\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u09E6-\\u09EF\\u09FE\\u0A01-\\u0A03\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A66-\\u0A71\\u0A75\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AE2\\u0AE3\\u0AE6-\\u0AEF\\u0AFA-\\u0AFF\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B55-\\u0B57\\u0B62\\u0B63\\u0B66-\\u0B6F\\u0B82\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C04\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C66-\\u0C6F\\u0C81-\\u0C83\\u0CBC\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0CE6-\\u0CEF\\u0D00-\\u0D03\\u0D3B\\u0D3C\\u0D3E-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D66-\\u0D6F\\u0D81-\\u0D83\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0E50-\\u0E59\\u0EB1\\u0EB4-\\u0EBC\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102B-\\u103E\\u1040-\\u1049\\u1056-\\u1059\\u105E-\\u1060\\u1062-\\u1064\\u1067-\\u106D\\u1071-\\u1074\\u1082-\\u108D\\u108F-\\u109D\\u135D-\\u135F\\u1369-\\u1371\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4-\\u17D3\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u18A9\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u194F\\u19D0-\\u19DA\\u1A17-\\u1A1B\\u1A55-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AB0-\\u1ABD\\u1ABF\\u1AC0\\u1B00-\\u1B04\\u1B34-\\u1B44\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1B82\\u1BA1-\\u1BAD\\u1BB0-\\u1BB9\\u1BE6-\\u1BF3\\u1C24-\\u1C37\\u1C40-\\u1C49\\u1C50-\\u1C59\\u1CD0-\\u1CD2\\u1CD4-\\u1CE8\\u1CED\\u1CF4\\u1CF7-\\u1CF9\\u1DC0-\\u1DF9\\u1DFB-\\u1DFF\\u203F\\u2040\\u2054\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA620-\\uA629\\uA66F\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA823-\\uA827\\uA82C\\uA880\\uA881\\uA8B4-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F1\\uA8FF-\\uA909\\uA926-\\uA92D\\uA947-\\uA953\\uA980-\\uA983\\uA9B3-\\uA9C0\\uA9D0-\\uA9D9\\uA9E5\\uA9F0-\\uA9F9\\uAA29-\\uAA36\\uAA43\\uAA4C\\uAA4D\\uAA50-\\uAA59\\uAA7B-\\uAA7D\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEB-\\uAAEF\\uAAF5\\uAAF6\\uABE3-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF10-\\uFF19\\uFF3F\";\nvar nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nvar nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\nvar astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];\nvar astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];\n\nfunction isInAstralSet(code, set) {\n  var pos = 0x10000;\n\n  for (var i = 0, length = set.length; i < length; i += 2) {\n    pos += set[i];\n    if (pos > code) return false;\n    pos += set[i + 1];\n    if (pos >= code) return true;\n  }\n\n  return false;\n}\n\nfunction isIdentifierStart(code) {\n  if (code < 65) return code === 36;\n  if (code <= 90) return true;\n  if (code < 97) return code === 95;\n  if (code <= 122) return true;\n\n  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));\n  }\n\n  return isInAstralSet(code, astralIdentifierStartCodes);\n}\n\nfunction isIdentifierChar(code) {\n  if (code < 48) return code === 36;\n  if (code < 58) return true;\n  if (code < 65) return false;\n  if (code <= 90) return true;\n  if (code < 97) return code === 95;\n  if (code <= 122) return true;\n\n  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n  }\n\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);\n}\n\nvar reservedWords = {\n  keyword: [\"break\", \"case\", \"catch\", \"continue\", \"debugger\", \"default\", \"do\", \"else\", \"finally\", \"for\", \"function\", \"if\", \"return\", \"switch\", \"throw\", \"try\", \"var\", \"const\", \"while\", \"with\", \"new\", \"this\", \"super\", \"class\", \"extends\", \"export\", \"import\", \"null\", \"true\", \"false\", \"in\", \"instanceof\", \"typeof\", \"void\", \"delete\"],\n  strict: [\"implements\", \"interface\", \"let\", \"package\", \"private\", \"protected\", \"public\", \"static\", \"yield\"],\n  strictBind: [\"eval\", \"arguments\"]\n};\nvar keywords$1 = new Set(reservedWords.keyword);\nvar reservedWordsStrictSet = new Set(reservedWords.strict);\nvar reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\nfunction isReservedWord(word, inModule) {\n  return inModule && word === \"await\" || word === \"enum\";\n}\n\nfunction isStrictReservedWord(word, inModule) {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\nfunction isStrictBindOnlyReservedWord(word) {\n  return reservedWordsStrictBindSet.has(word);\n}\n\nfunction isStrictBindReservedWord(word, inModule) {\n  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);\n}\n\nfunction isKeyword(word) {\n  return keywords$1.has(word);\n}\n\nvar keywordRelationalOperator = /^in(stanceof)?$/;\n\nfunction isIteratorStart(current, next) {\n  return current === 64 && next === 64;\n}\n\nvar reservedTypes = new Set([\"_\", \"any\", \"bool\", \"boolean\", \"empty\", \"extends\", \"false\", \"interface\", \"mixed\", \"null\", \"number\", \"static\", \"string\", \"true\", \"typeof\", \"void\"]);\nvar FlowErrors = Object.freeze({\n  AmbiguousConditionalArrow: \"Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.\",\n  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\",\n  AssignReservedType: \"Cannot overwrite reserved type %0\",\n  DeclareClassElement: \"The `declare` modifier can only appear on class fields.\",\n  DeclareClassFieldInitializer: \"Initializers are not allowed in fields with the `declare` modifier.\",\n  DuplicateDeclareModuleExports: \"Duplicate `declare module.exports` statement\",\n  EnumBooleanMemberNotInitialized: \"Boolean enum members need to be initialized. Use either `%0 = true,` or `%0 = false,` in enum `%1`.\",\n  EnumDuplicateMemberName: \"Enum member names need to be unique, but the name `%0` has already been used before in enum `%1`.\",\n  EnumInconsistentMemberValues: \"Enum `%0` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.\",\n  EnumInvalidExplicitType: \"Enum type `%1` is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.\",\n  EnumInvalidExplicitTypeUnknownSupplied: \"Supplied enum type is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.\",\n  EnumInvalidMemberInitializerPrimaryType: \"Enum `%0` has type `%2`, so the initializer of `%1` needs to be a %2 literal.\",\n  EnumInvalidMemberInitializerSymbolType: \"Symbol enum members cannot be initialized. Use `%1,` in enum `%0`.\",\n  EnumInvalidMemberInitializerUnknownType: \"The enum member initializer for `%1` needs to be a literal (either a boolean, number, or string) in enum `%0`.\",\n  EnumInvalidMemberName: \"Enum member names cannot start with lowercase 'a' through 'z'. Instead of using `%0`, consider using `%1`, in enum `%2`.\",\n  EnumNumberMemberNotInitialized: \"Number enum members need to be initialized, e.g. `%1 = 1` in enum `%0`.\",\n  EnumStringMemberInconsistentlyInitailized: \"String enum members need to consistently either all use initializers, or use no initializers, in enum `%0`.\",\n  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\",\n  InexactInsideExact: \"Explicit inexact syntax cannot appear inside an explicit exact object type\",\n  InexactInsideNonObject: \"Explicit inexact syntax cannot appear in class or interface definitions\",\n  InexactVariance: \"Explicit inexact syntax cannot have variance\",\n  InvalidNonTypeImportInDeclareModule: \"Imports within a `declare module` body must always be `import type` or `import typeof`\",\n  MissingTypeParamDefault: \"Type parameter declaration needs a default, since a preceding type parameter declaration has a default.\",\n  NestedDeclareModule: \"`declare module` cannot be used inside another `declare module`\",\n  NestedFlowComment: \"Cannot have a flow comment inside another flow comment\",\n  OptionalBindingPattern: \"A binding pattern parameter cannot be optional in an implementation signature.\",\n  SpreadVariance: \"Spread properties cannot have variance\",\n  TypeBeforeInitializer: \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`\",\n  TypeCastInPattern: \"The type cast expression is expected to be wrapped with parenthesis\",\n  UnexpectedExplicitInexactInObject: \"Explicit inexact syntax must appear at the end of an inexact object\",\n  UnexpectedReservedType: \"Unexpected reserved type %0\",\n  UnexpectedReservedUnderscore: \"`_` is only allowed as a type argument to call or new\",\n  UnexpectedSpaceBetweenModuloChecks: \"Spaces between `%` and `checks` are not allowed here.\",\n  UnexpectedSpreadType: \"Spread operator cannot appear in class or interface definitions\",\n  UnexpectedSubtractionOperand: 'Unexpected token, expected \"number\" or \"bigint\"',\n  UnexpectedTokenAfterTypeParameter: \"Expected an arrow function after this type parameter declaration\",\n  UnexpectedTypeParameterBeforeAsyncArrowFunction: \"Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`\",\n  UnsupportedDeclareExportKind: \"`declare export %0` is not supported. Use `%1` instead\",\n  UnsupportedStatementInDeclareModule: \"Only declares and type imports are allowed inside declare module\",\n  UnterminatedFlowComment: \"Unterminated flow-comment\"\n});\n\nfunction isEsModuleType(bodyElement) {\n  return bodyElement.type === \"DeclareExportAllDeclaration\" || bodyElement.type === \"DeclareExportDeclaration\" && (!bodyElement.declaration || bodyElement.declaration.type !== \"TypeAlias\" && bodyElement.declaration.type !== \"InterfaceDeclaration\");\n}\n\nfunction hasTypeImportKind(node) {\n  return node.importKind === \"type\" || node.importKind === \"typeof\";\n}\n\nfunction isMaybeDefaultImport(state) {\n  return (state.type === types.name || !!state.type.keyword) && state.value !== \"from\";\n}\n\nvar exportSuggestions = {\n  const: \"declare export var\",\n  let: \"declare export var\",\n  type: \"export type\",\n  interface: \"export interface\"\n};\n\nfunction partition(list, test) {\n  var list1 = [];\n  var list2 = [];\n\n  for (var i = 0; i < list.length; i++) {\n    (test(list[i], i, list) ? list1 : list2).push(list[i]);\n  }\n\n  return [list1, list2];\n}\n\nvar FLOW_PRAGMA_REGEX = /\\*?\\s*@((?:no)?flow)\\b/;\n\nvar flow = function flow(superClass) {\n  return /*#__PURE__*/function (_superClass2) {\n    _inherits(_class2, _superClass2);\n\n    var _super4 = _createSuper(_class2);\n\n    function _class2(options, input) {\n      var _this3;\n\n      _classCallCheck(this, _class2);\n\n      _this3 = _super4.call(this, options, input);\n      _this3.flowPragma = undefined;\n      return _this3;\n    }\n\n    _createClass(_class2, [{\n      key: \"shouldParseTypes\",\n      value: function shouldParseTypes() {\n        return this.getPluginOption(\"flow\", \"all\") || this.flowPragma === \"flow\";\n      }\n    }, {\n      key: \"shouldParseEnums\",\n      value: function shouldParseEnums() {\n        return !!this.getPluginOption(\"flow\", \"enums\");\n      }\n    }, {\n      key: \"finishToken\",\n      value: function finishToken(type, val) {\n        if (type !== types.string && type !== types.semi && type !== types.interpreterDirective) {\n          if (this.flowPragma === undefined) {\n            this.flowPragma = null;\n          }\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"finishToken\", this).call(this, type, val);\n      }\n    }, {\n      key: \"addComment\",\n      value: function addComment(comment) {\n        if (this.flowPragma === undefined) {\n          var matches = FLOW_PRAGMA_REGEX.exec(comment.value);\n          if (!matches) ;else if (matches[1] === \"flow\") {\n            this.flowPragma = \"flow\";\n          } else if (matches[1] === \"noflow\") {\n            this.flowPragma = \"noflow\";\n          } else {\n            throw new Error(\"Unexpected flow pragma\");\n          }\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"addComment\", this).call(this, comment);\n      }\n    }, {\n      key: \"flowParseTypeInitialiser\",\n      value: function flowParseTypeInitialiser(tok) {\n        var oldInType = this.state.inType;\n        this.state.inType = true;\n        this.expect(tok || types.colon);\n        var type = this.flowParseType();\n        this.state.inType = oldInType;\n        return type;\n      }\n    }, {\n      key: \"flowParsePredicate\",\n      value: function flowParsePredicate() {\n        var node = this.startNode();\n        var moduloLoc = this.state.startLoc;\n        var moduloPos = this.state.start;\n        this.expect(types.modulo);\n        var checksLoc = this.state.startLoc;\n        this.expectContextual(\"checks\");\n\n        if (moduloLoc.line !== checksLoc.line || moduloLoc.column !== checksLoc.column - 1) {\n          this.raise(moduloPos, FlowErrors.UnexpectedSpaceBetweenModuloChecks);\n        }\n\n        if (this.eat(types.parenL)) {\n          node.value = this.parseExpression();\n          this.expect(types.parenR);\n          return this.finishNode(node, \"DeclaredPredicate\");\n        } else {\n          return this.finishNode(node, \"InferredPredicate\");\n        }\n      }\n    }, {\n      key: \"flowParseTypeAndPredicateInitialiser\",\n      value: function flowParseTypeAndPredicateInitialiser() {\n        var oldInType = this.state.inType;\n        this.state.inType = true;\n        this.expect(types.colon);\n        var type = null;\n        var predicate = null;\n\n        if (this.match(types.modulo)) {\n          this.state.inType = oldInType;\n          predicate = this.flowParsePredicate();\n        } else {\n          type = this.flowParseType();\n          this.state.inType = oldInType;\n\n          if (this.match(types.modulo)) {\n            predicate = this.flowParsePredicate();\n          }\n        }\n\n        return [type, predicate];\n      }\n    }, {\n      key: \"flowParseDeclareClass\",\n      value: function flowParseDeclareClass(node) {\n        this.next();\n        this.flowParseInterfaceish(node, true);\n        return this.finishNode(node, \"DeclareClass\");\n      }\n    }, {\n      key: \"flowParseDeclareFunction\",\n      value: function flowParseDeclareFunction(node) {\n        this.next();\n        var id = node.id = this.parseIdentifier();\n        var typeNode = this.startNode();\n        var typeContainer = this.startNode();\n\n        if (this.isRelational(\"<\")) {\n          typeNode.typeParameters = this.flowParseTypeParameterDeclaration();\n        } else {\n          typeNode.typeParameters = null;\n        }\n\n        this.expect(types.parenL);\n        var tmp = this.flowParseFunctionTypeParams();\n        typeNode.params = tmp.params;\n        typeNode.rest = tmp.rest;\n        this.expect(types.parenR);\n\n        var _this$flowParseTypeAn = this.flowParseTypeAndPredicateInitialiser();\n\n        var _this$flowParseTypeAn2 = _slicedToArray(_this$flowParseTypeAn, 2);\n\n        typeNode.returnType = _this$flowParseTypeAn2[0];\n        node.predicate = _this$flowParseTypeAn2[1];\n        typeContainer.typeAnnotation = this.finishNode(typeNode, \"FunctionTypeAnnotation\");\n        id.typeAnnotation = this.finishNode(typeContainer, \"TypeAnnotation\");\n        this.resetEndLocation(id);\n        this.semicolon();\n        return this.finishNode(node, \"DeclareFunction\");\n      }\n    }, {\n      key: \"flowParseDeclare\",\n      value: function flowParseDeclare(node, insideModule) {\n        if (this.match(types._class)) {\n          return this.flowParseDeclareClass(node);\n        } else if (this.match(types._function)) {\n          return this.flowParseDeclareFunction(node);\n        } else if (this.match(types._var)) {\n          return this.flowParseDeclareVariable(node);\n        } else if (this.eatContextual(\"module\")) {\n          if (this.match(types.dot)) {\n            return this.flowParseDeclareModuleExports(node);\n          } else {\n            if (insideModule) {\n              this.raise(this.state.lastTokStart, FlowErrors.NestedDeclareModule);\n            }\n\n            return this.flowParseDeclareModule(node);\n          }\n        } else if (this.isContextual(\"type\")) {\n          return this.flowParseDeclareTypeAlias(node);\n        } else if (this.isContextual(\"opaque\")) {\n          return this.flowParseDeclareOpaqueType(node);\n        } else if (this.isContextual(\"interface\")) {\n          return this.flowParseDeclareInterface(node);\n        } else if (this.match(types._export)) {\n          return this.flowParseDeclareExportDeclaration(node, insideModule);\n        } else {\n          throw this.unexpected();\n        }\n      }\n    }, {\n      key: \"flowParseDeclareVariable\",\n      value: function flowParseDeclareVariable(node) {\n        this.next();\n        node.id = this.flowParseTypeAnnotatableIdentifier(true);\n        this.scope.declareName(node.id.name, BIND_VAR, node.id.start);\n        this.semicolon();\n        return this.finishNode(node, \"DeclareVariable\");\n      }\n    }, {\n      key: \"flowParseDeclareModule\",\n      value: function flowParseDeclareModule(node) {\n        var _this4 = this;\n\n        this.scope.enter(SCOPE_OTHER);\n\n        if (this.match(types.string)) {\n          node.id = this.parseExprAtom();\n        } else {\n          node.id = this.parseIdentifier();\n        }\n\n        var bodyNode = node.body = this.startNode();\n        var body = bodyNode.body = [];\n        this.expect(types.braceL);\n\n        while (!this.match(types.braceR)) {\n          var _bodyNode = this.startNode();\n\n          if (this.match(types._import)) {\n            this.next();\n\n            if (!this.isContextual(\"type\") && !this.match(types._typeof)) {\n              this.raise(this.state.lastTokStart, FlowErrors.InvalidNonTypeImportInDeclareModule);\n            }\n\n            this.parseImport(_bodyNode);\n          } else {\n            this.expectContextual(\"declare\", FlowErrors.UnsupportedStatementInDeclareModule);\n            _bodyNode = this.flowParseDeclare(_bodyNode, true);\n          }\n\n          body.push(_bodyNode);\n        }\n\n        this.scope.exit();\n        this.expect(types.braceR);\n        this.finishNode(bodyNode, \"BlockStatement\");\n        var kind = null;\n        var hasModuleExport = false;\n        body.forEach(function (bodyElement) {\n          if (isEsModuleType(bodyElement)) {\n            if (kind === \"CommonJS\") {\n              _this4.raise(bodyElement.start, FlowErrors.AmbiguousDeclareModuleKind);\n            }\n\n            kind = \"ES\";\n          } else if (bodyElement.type === \"DeclareModuleExports\") {\n            if (hasModuleExport) {\n              _this4.raise(bodyElement.start, FlowErrors.DuplicateDeclareModuleExports);\n            }\n\n            if (kind === \"ES\") {\n              _this4.raise(bodyElement.start, FlowErrors.AmbiguousDeclareModuleKind);\n            }\n\n            kind = \"CommonJS\";\n            hasModuleExport = true;\n          }\n        });\n        node.kind = kind || \"CommonJS\";\n        return this.finishNode(node, \"DeclareModule\");\n      }\n    }, {\n      key: \"flowParseDeclareExportDeclaration\",\n      value: function flowParseDeclareExportDeclaration(node, insideModule) {\n        this.expect(types._export);\n\n        if (this.eat(types._default)) {\n          if (this.match(types._function) || this.match(types._class)) {\n            node.declaration = this.flowParseDeclare(this.startNode());\n          } else {\n            node.declaration = this.flowParseType();\n            this.semicolon();\n          }\n\n          node.default = true;\n          return this.finishNode(node, \"DeclareExportDeclaration\");\n        } else {\n          if (this.match(types._const) || this.isLet() || (this.isContextual(\"type\") || this.isContextual(\"interface\")) && !insideModule) {\n            var label = this.state.value;\n            var suggestion = exportSuggestions[label];\n            throw this.raise(this.state.start, FlowErrors.UnsupportedDeclareExportKind, label, suggestion);\n          }\n\n          if (this.match(types._var) || this.match(types._function) || this.match(types._class) || this.isContextual(\"opaque\")) {\n            node.declaration = this.flowParseDeclare(this.startNode());\n            node.default = false;\n            return this.finishNode(node, \"DeclareExportDeclaration\");\n          } else if (this.match(types.star) || this.match(types.braceL) || this.isContextual(\"interface\") || this.isContextual(\"type\") || this.isContextual(\"opaque\")) {\n            node = this.parseExport(node);\n\n            if (node.type === \"ExportNamedDeclaration\") {\n              node.type = \"ExportDeclaration\";\n              node.default = false;\n              delete node.exportKind;\n            }\n\n            node.type = \"Declare\" + node.type;\n            return node;\n          }\n        }\n\n        throw this.unexpected();\n      }\n    }, {\n      key: \"flowParseDeclareModuleExports\",\n      value: function flowParseDeclareModuleExports(node) {\n        this.next();\n        this.expectContextual(\"exports\");\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n        this.semicolon();\n        return this.finishNode(node, \"DeclareModuleExports\");\n      }\n    }, {\n      key: \"flowParseDeclareTypeAlias\",\n      value: function flowParseDeclareTypeAlias(node) {\n        this.next();\n        this.flowParseTypeAlias(node);\n        node.type = \"DeclareTypeAlias\";\n        return node;\n      }\n    }, {\n      key: \"flowParseDeclareOpaqueType\",\n      value: function flowParseDeclareOpaqueType(node) {\n        this.next();\n        this.flowParseOpaqueType(node, true);\n        node.type = \"DeclareOpaqueType\";\n        return node;\n      }\n    }, {\n      key: \"flowParseDeclareInterface\",\n      value: function flowParseDeclareInterface(node) {\n        this.next();\n        this.flowParseInterfaceish(node);\n        return this.finishNode(node, \"DeclareInterface\");\n      }\n    }, {\n      key: \"flowParseInterfaceish\",\n      value: function flowParseInterfaceish(node) {\n        var isClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n        node.id = this.flowParseRestrictedIdentifier(!isClass, true);\n        this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.start);\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n        } else {\n          node.typeParameters = null;\n        }\n\n        node.extends = [];\n        node.implements = [];\n        node.mixins = [];\n\n        if (this.eat(types._extends)) {\n          do {\n            node.extends.push(this.flowParseInterfaceExtends());\n          } while (!isClass && this.eat(types.comma));\n        }\n\n        if (this.isContextual(\"mixins\")) {\n          this.next();\n\n          do {\n            node.mixins.push(this.flowParseInterfaceExtends());\n          } while (this.eat(types.comma));\n        }\n\n        if (this.isContextual(\"implements\")) {\n          this.next();\n\n          do {\n            node.implements.push(this.flowParseInterfaceExtends());\n          } while (this.eat(types.comma));\n        }\n\n        node.body = this.flowParseObjectType({\n          allowStatic: isClass,\n          allowExact: false,\n          allowSpread: false,\n          allowProto: isClass,\n          allowInexact: false\n        });\n      }\n    }, {\n      key: \"flowParseInterfaceExtends\",\n      value: function flowParseInterfaceExtends() {\n        var node = this.startNode();\n        node.id = this.flowParseQualifiedTypeIdentifier();\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterInstantiation();\n        } else {\n          node.typeParameters = null;\n        }\n\n        return this.finishNode(node, \"InterfaceExtends\");\n      }\n    }, {\n      key: \"flowParseInterface\",\n      value: function flowParseInterface(node) {\n        this.flowParseInterfaceish(node);\n        return this.finishNode(node, \"InterfaceDeclaration\");\n      }\n    }, {\n      key: \"checkNotUnderscore\",\n      value: function checkNotUnderscore(word) {\n        if (word === \"_\") {\n          this.raise(this.state.start, FlowErrors.UnexpectedReservedUnderscore);\n        }\n      }\n    }, {\n      key: \"checkReservedType\",\n      value: function checkReservedType(word, startLoc, declaration) {\n        if (!reservedTypes.has(word)) return;\n        this.raise(startLoc, declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, word);\n      }\n    }, {\n      key: \"flowParseRestrictedIdentifier\",\n      value: function flowParseRestrictedIdentifier(liberal, declaration) {\n        this.checkReservedType(this.state.value, this.state.start, declaration);\n        return this.parseIdentifier(liberal);\n      }\n    }, {\n      key: \"flowParseTypeAlias\",\n      value: function flowParseTypeAlias(node) {\n        node.id = this.flowParseRestrictedIdentifier(false, true);\n        this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.start);\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n        } else {\n          node.typeParameters = null;\n        }\n\n        node.right = this.flowParseTypeInitialiser(types.eq);\n        this.semicolon();\n        return this.finishNode(node, \"TypeAlias\");\n      }\n    }, {\n      key: \"flowParseOpaqueType\",\n      value: function flowParseOpaqueType(node, declare) {\n        this.expectContextual(\"type\");\n        node.id = this.flowParseRestrictedIdentifier(true, true);\n        this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.start);\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n        } else {\n          node.typeParameters = null;\n        }\n\n        node.supertype = null;\n\n        if (this.match(types.colon)) {\n          node.supertype = this.flowParseTypeInitialiser(types.colon);\n        }\n\n        node.impltype = null;\n\n        if (!declare) {\n          node.impltype = this.flowParseTypeInitialiser(types.eq);\n        }\n\n        this.semicolon();\n        return this.finishNode(node, \"OpaqueType\");\n      }\n    }, {\n      key: \"flowParseTypeParameter\",\n      value: function flowParseTypeParameter() {\n        var requireDefault = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n        var nodeStart = this.state.start;\n        var node = this.startNode();\n        var variance = this.flowParseVariance();\n        var ident = this.flowParseTypeAnnotatableIdentifier();\n        node.name = ident.name;\n        node.variance = variance;\n        node.bound = ident.typeAnnotation;\n\n        if (this.match(types.eq)) {\n          this.eat(types.eq);\n          node.default = this.flowParseType();\n        } else {\n          if (requireDefault) {\n            this.raise(nodeStart, FlowErrors.MissingTypeParamDefault);\n          }\n        }\n\n        return this.finishNode(node, \"TypeParameter\");\n      }\n    }, {\n      key: \"flowParseTypeParameterDeclaration\",\n      value: function flowParseTypeParameterDeclaration() {\n        var oldInType = this.state.inType;\n        var node = this.startNode();\n        node.params = [];\n        this.state.inType = true;\n\n        if (this.isRelational(\"<\") || this.match(types.jsxTagStart)) {\n          this.next();\n        } else {\n          this.unexpected();\n        }\n\n        var defaultRequired = false;\n\n        do {\n          var typeParameter = this.flowParseTypeParameter(defaultRequired);\n          node.params.push(typeParameter);\n\n          if (typeParameter.default) {\n            defaultRequired = true;\n          }\n\n          if (!this.isRelational(\">\")) {\n            this.expect(types.comma);\n          }\n        } while (!this.isRelational(\">\"));\n\n        this.expectRelational(\">\");\n        this.state.inType = oldInType;\n        return this.finishNode(node, \"TypeParameterDeclaration\");\n      }\n    }, {\n      key: \"flowParseTypeParameterInstantiation\",\n      value: function flowParseTypeParameterInstantiation() {\n        var node = this.startNode();\n        var oldInType = this.state.inType;\n        node.params = [];\n        this.state.inType = true;\n        this.expectRelational(\"<\");\n        var oldNoAnonFunctionType = this.state.noAnonFunctionType;\n        this.state.noAnonFunctionType = false;\n\n        while (!this.isRelational(\">\")) {\n          node.params.push(this.flowParseType());\n\n          if (!this.isRelational(\">\")) {\n            this.expect(types.comma);\n          }\n        }\n\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n        this.expectRelational(\">\");\n        this.state.inType = oldInType;\n        return this.finishNode(node, \"TypeParameterInstantiation\");\n      }\n    }, {\n      key: \"flowParseTypeParameterInstantiationCallOrNew\",\n      value: function flowParseTypeParameterInstantiationCallOrNew() {\n        var node = this.startNode();\n        var oldInType = this.state.inType;\n        node.params = [];\n        this.state.inType = true;\n        this.expectRelational(\"<\");\n\n        while (!this.isRelational(\">\")) {\n          node.params.push(this.flowParseTypeOrImplicitInstantiation());\n\n          if (!this.isRelational(\">\")) {\n            this.expect(types.comma);\n          }\n        }\n\n        this.expectRelational(\">\");\n        this.state.inType = oldInType;\n        return this.finishNode(node, \"TypeParameterInstantiation\");\n      }\n    }, {\n      key: \"flowParseInterfaceType\",\n      value: function flowParseInterfaceType() {\n        var node = this.startNode();\n        this.expectContextual(\"interface\");\n        node.extends = [];\n\n        if (this.eat(types._extends)) {\n          do {\n            node.extends.push(this.flowParseInterfaceExtends());\n          } while (this.eat(types.comma));\n        }\n\n        node.body = this.flowParseObjectType({\n          allowStatic: false,\n          allowExact: false,\n          allowSpread: false,\n          allowProto: false,\n          allowInexact: false\n        });\n        return this.finishNode(node, \"InterfaceTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseObjectPropertyKey\",\n      value: function flowParseObjectPropertyKey() {\n        return this.match(types.num) || this.match(types.string) ? this.parseExprAtom() : this.parseIdentifier(true);\n      }\n    }, {\n      key: \"flowParseObjectTypeIndexer\",\n      value: function flowParseObjectTypeIndexer(node, isStatic, variance) {\n        node.static = isStatic;\n\n        if (this.lookahead().type === types.colon) {\n          node.id = this.flowParseObjectPropertyKey();\n          node.key = this.flowParseTypeInitialiser();\n        } else {\n          node.id = null;\n          node.key = this.flowParseType();\n        }\n\n        this.expect(types.bracketR);\n        node.value = this.flowParseTypeInitialiser();\n        node.variance = variance;\n        return this.finishNode(node, \"ObjectTypeIndexer\");\n      }\n    }, {\n      key: \"flowParseObjectTypeInternalSlot\",\n      value: function flowParseObjectTypeInternalSlot(node, isStatic) {\n        node.static = isStatic;\n        node.id = this.flowParseObjectPropertyKey();\n        this.expect(types.bracketR);\n        this.expect(types.bracketR);\n\n        if (this.isRelational(\"<\") || this.match(types.parenL)) {\n          node.method = true;\n          node.optional = false;\n          node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));\n        } else {\n          node.method = false;\n\n          if (this.eat(types.question)) {\n            node.optional = true;\n          }\n\n          node.value = this.flowParseTypeInitialiser();\n        }\n\n        return this.finishNode(node, \"ObjectTypeInternalSlot\");\n      }\n    }, {\n      key: \"flowParseObjectTypeMethodish\",\n      value: function flowParseObjectTypeMethodish(node) {\n        node.params = [];\n        node.rest = null;\n        node.typeParameters = null;\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n        }\n\n        this.expect(types.parenL);\n\n        while (!this.match(types.parenR) && !this.match(types.ellipsis)) {\n          node.params.push(this.flowParseFunctionTypeParam());\n\n          if (!this.match(types.parenR)) {\n            this.expect(types.comma);\n          }\n        }\n\n        if (this.eat(types.ellipsis)) {\n          node.rest = this.flowParseFunctionTypeParam();\n        }\n\n        this.expect(types.parenR);\n        node.returnType = this.flowParseTypeInitialiser();\n        return this.finishNode(node, \"FunctionTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseObjectTypeCallProperty\",\n      value: function flowParseObjectTypeCallProperty(node, isStatic) {\n        var valueNode = this.startNode();\n        node.static = isStatic;\n        node.value = this.flowParseObjectTypeMethodish(valueNode);\n        return this.finishNode(node, \"ObjectTypeCallProperty\");\n      }\n    }, {\n      key: \"flowParseObjectType\",\n      value: function flowParseObjectType(_ref2) {\n        var allowStatic = _ref2.allowStatic,\n            allowExact = _ref2.allowExact,\n            allowSpread = _ref2.allowSpread,\n            allowProto = _ref2.allowProto,\n            allowInexact = _ref2.allowInexact;\n        var oldInType = this.state.inType;\n        this.state.inType = true;\n        var nodeStart = this.startNode();\n        nodeStart.callProperties = [];\n        nodeStart.properties = [];\n        nodeStart.indexers = [];\n        nodeStart.internalSlots = [];\n        var endDelim;\n        var exact;\n        var inexact = false;\n\n        if (allowExact && this.match(types.braceBarL)) {\n          this.expect(types.braceBarL);\n          endDelim = types.braceBarR;\n          exact = true;\n        } else {\n          this.expect(types.braceL);\n          endDelim = types.braceR;\n          exact = false;\n        }\n\n        nodeStart.exact = exact;\n\n        while (!this.match(endDelim)) {\n          var isStatic = false;\n          var protoStart = null;\n          var inexactStart = null;\n          var node = this.startNode();\n\n          if (allowProto && this.isContextual(\"proto\")) {\n            var lookahead = this.lookahead();\n\n            if (lookahead.type !== types.colon && lookahead.type !== types.question) {\n              this.next();\n              protoStart = this.state.start;\n              allowStatic = false;\n            }\n          }\n\n          if (allowStatic && this.isContextual(\"static\")) {\n            var _lookahead = this.lookahead();\n\n            if (_lookahead.type !== types.colon && _lookahead.type !== types.question) {\n              this.next();\n              isStatic = true;\n            }\n          }\n\n          var variance = this.flowParseVariance();\n\n          if (this.eat(types.bracketL)) {\n            if (protoStart != null) {\n              this.unexpected(protoStart);\n            }\n\n            if (this.eat(types.bracketL)) {\n              if (variance) {\n                this.unexpected(variance.start);\n              }\n\n              nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));\n            } else {\n              nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));\n            }\n          } else if (this.match(types.parenL) || this.isRelational(\"<\")) {\n            if (protoStart != null) {\n              this.unexpected(protoStart);\n            }\n\n            if (variance) {\n              this.unexpected(variance.start);\n            }\n\n            nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));\n          } else {\n            var kind = \"init\";\n\n            if (this.isContextual(\"get\") || this.isContextual(\"set\")) {\n              var _lookahead2 = this.lookahead();\n\n              if (_lookahead2.type === types.name || _lookahead2.type === types.string || _lookahead2.type === types.num) {\n                kind = this.state.value;\n                this.next();\n              }\n            }\n\n            var propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);\n\n            if (propOrInexact === null) {\n              inexact = true;\n              inexactStart = this.state.lastTokStart;\n            } else {\n              nodeStart.properties.push(propOrInexact);\n            }\n          }\n\n          this.flowObjectTypeSemicolon();\n\n          if (inexactStart && !this.match(types.braceR) && !this.match(types.braceBarR)) {\n            this.raise(inexactStart, FlowErrors.UnexpectedExplicitInexactInObject);\n          }\n        }\n\n        this.expect(endDelim);\n\n        if (allowSpread) {\n          nodeStart.inexact = inexact;\n        }\n\n        var out = this.finishNode(nodeStart, \"ObjectTypeAnnotation\");\n        this.state.inType = oldInType;\n        return out;\n      }\n    }, {\n      key: \"flowParseObjectTypeProperty\",\n      value: function flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact) {\n        if (this.eat(types.ellipsis)) {\n          var isInexactToken = this.match(types.comma) || this.match(types.semi) || this.match(types.braceR) || this.match(types.braceBarR);\n\n          if (isInexactToken) {\n            if (!allowSpread) {\n              this.raise(this.state.lastTokStart, FlowErrors.InexactInsideNonObject);\n            } else if (!allowInexact) {\n              this.raise(this.state.lastTokStart, FlowErrors.InexactInsideExact);\n            }\n\n            if (variance) {\n              this.raise(variance.start, FlowErrors.InexactVariance);\n            }\n\n            return null;\n          }\n\n          if (!allowSpread) {\n            this.raise(this.state.lastTokStart, FlowErrors.UnexpectedSpreadType);\n          }\n\n          if (protoStart != null) {\n            this.unexpected(protoStart);\n          }\n\n          if (variance) {\n            this.raise(variance.start, FlowErrors.SpreadVariance);\n          }\n\n          node.argument = this.flowParseType();\n          return this.finishNode(node, \"ObjectTypeSpreadProperty\");\n        } else {\n          node.key = this.flowParseObjectPropertyKey();\n          node.static = isStatic;\n          node.proto = protoStart != null;\n          node.kind = kind;\n          var optional = false;\n\n          if (this.isRelational(\"<\") || this.match(types.parenL)) {\n            node.method = true;\n\n            if (protoStart != null) {\n              this.unexpected(protoStart);\n            }\n\n            if (variance) {\n              this.unexpected(variance.start);\n            }\n\n            node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));\n\n            if (kind === \"get\" || kind === \"set\") {\n              this.flowCheckGetterSetterParams(node);\n            }\n          } else {\n            if (kind !== \"init\") this.unexpected();\n            node.method = false;\n\n            if (this.eat(types.question)) {\n              optional = true;\n            }\n\n            node.value = this.flowParseTypeInitialiser();\n            node.variance = variance;\n          }\n\n          node.optional = optional;\n          return this.finishNode(node, \"ObjectTypeProperty\");\n        }\n      }\n    }, {\n      key: \"flowCheckGetterSetterParams\",\n      value: function flowCheckGetterSetterParams(property) {\n        var paramCount = property.kind === \"get\" ? 0 : 1;\n        var start = property.start;\n        var length = property.value.params.length + (property.value.rest ? 1 : 0);\n\n        if (length !== paramCount) {\n          if (property.kind === \"get\") {\n            this.raise(start, ErrorMessages.BadGetterArity);\n          } else {\n            this.raise(start, ErrorMessages.BadSetterArity);\n          }\n        }\n\n        if (property.kind === \"set\" && property.value.rest) {\n          this.raise(start, ErrorMessages.BadSetterRestParameter);\n        }\n      }\n    }, {\n      key: \"flowObjectTypeSemicolon\",\n      value: function flowObjectTypeSemicolon() {\n        if (!this.eat(types.semi) && !this.eat(types.comma) && !this.match(types.braceR) && !this.match(types.braceBarR)) {\n          this.unexpected();\n        }\n      }\n    }, {\n      key: \"flowParseQualifiedTypeIdentifier\",\n      value: function flowParseQualifiedTypeIdentifier(startPos, startLoc, id) {\n        startPos = startPos || this.state.start;\n        startLoc = startLoc || this.state.startLoc;\n        var node = id || this.flowParseRestrictedIdentifier(true);\n\n        while (this.eat(types.dot)) {\n          var node2 = this.startNodeAt(startPos, startLoc);\n          node2.qualification = node;\n          node2.id = this.flowParseRestrictedIdentifier(true);\n          node = this.finishNode(node2, \"QualifiedTypeIdentifier\");\n        }\n\n        return node;\n      }\n    }, {\n      key: \"flowParseGenericType\",\n      value: function flowParseGenericType(startPos, startLoc, id) {\n        var node = this.startNodeAt(startPos, startLoc);\n        node.typeParameters = null;\n        node.id = this.flowParseQualifiedTypeIdentifier(startPos, startLoc, id);\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterInstantiation();\n        }\n\n        return this.finishNode(node, \"GenericTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseTypeofType\",\n      value: function flowParseTypeofType() {\n        var node = this.startNode();\n        this.expect(types._typeof);\n        node.argument = this.flowParsePrimaryType();\n        return this.finishNode(node, \"TypeofTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseTupleType\",\n      value: function flowParseTupleType() {\n        var node = this.startNode();\n        node.types = [];\n        this.expect(types.bracketL);\n\n        while (this.state.pos < this.length && !this.match(types.bracketR)) {\n          node.types.push(this.flowParseType());\n          if (this.match(types.bracketR)) break;\n          this.expect(types.comma);\n        }\n\n        this.expect(types.bracketR);\n        return this.finishNode(node, \"TupleTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseFunctionTypeParam\",\n      value: function flowParseFunctionTypeParam() {\n        var name = null;\n        var optional = false;\n        var typeAnnotation = null;\n        var node = this.startNode();\n        var lh = this.lookahead();\n\n        if (lh.type === types.colon || lh.type === types.question) {\n          name = this.parseIdentifier();\n\n          if (this.eat(types.question)) {\n            optional = true;\n          }\n\n          typeAnnotation = this.flowParseTypeInitialiser();\n        } else {\n          typeAnnotation = this.flowParseType();\n        }\n\n        node.name = name;\n        node.optional = optional;\n        node.typeAnnotation = typeAnnotation;\n        return this.finishNode(node, \"FunctionTypeParam\");\n      }\n    }, {\n      key: \"reinterpretTypeAsFunctionTypeParam\",\n      value: function reinterpretTypeAsFunctionTypeParam(type) {\n        var node = this.startNodeAt(type.start, type.loc.start);\n        node.name = null;\n        node.optional = false;\n        node.typeAnnotation = type;\n        return this.finishNode(node, \"FunctionTypeParam\");\n      }\n    }, {\n      key: \"flowParseFunctionTypeParams\",\n      value: function flowParseFunctionTypeParams() {\n        var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n        var rest = null;\n\n        while (!this.match(types.parenR) && !this.match(types.ellipsis)) {\n          params.push(this.flowParseFunctionTypeParam());\n\n          if (!this.match(types.parenR)) {\n            this.expect(types.comma);\n          }\n        }\n\n        if (this.eat(types.ellipsis)) {\n          rest = this.flowParseFunctionTypeParam();\n        }\n\n        return {\n          params: params,\n          rest: rest\n        };\n      }\n    }, {\n      key: \"flowIdentToTypeAnnotation\",\n      value: function flowIdentToTypeAnnotation(startPos, startLoc, node, id) {\n        switch (id.name) {\n          case \"any\":\n            return this.finishNode(node, \"AnyTypeAnnotation\");\n\n          case \"bool\":\n          case \"boolean\":\n            return this.finishNode(node, \"BooleanTypeAnnotation\");\n\n          case \"mixed\":\n            return this.finishNode(node, \"MixedTypeAnnotation\");\n\n          case \"empty\":\n            return this.finishNode(node, \"EmptyTypeAnnotation\");\n\n          case \"number\":\n            return this.finishNode(node, \"NumberTypeAnnotation\");\n\n          case \"string\":\n            return this.finishNode(node, \"StringTypeAnnotation\");\n\n          case \"symbol\":\n            return this.finishNode(node, \"SymbolTypeAnnotation\");\n\n          default:\n            this.checkNotUnderscore(id.name);\n            return this.flowParseGenericType(startPos, startLoc, id);\n        }\n      }\n    }, {\n      key: \"flowParsePrimaryType\",\n      value: function flowParsePrimaryType() {\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        var node = this.startNode();\n        var tmp;\n        var type;\n        var isGroupedType = false;\n        var oldNoAnonFunctionType = this.state.noAnonFunctionType;\n\n        switch (this.state.type) {\n          case types.name:\n            if (this.isContextual(\"interface\")) {\n              return this.flowParseInterfaceType();\n            }\n\n            return this.flowIdentToTypeAnnotation(startPos, startLoc, node, this.parseIdentifier());\n\n          case types.braceL:\n            return this.flowParseObjectType({\n              allowStatic: false,\n              allowExact: false,\n              allowSpread: true,\n              allowProto: false,\n              allowInexact: true\n            });\n\n          case types.braceBarL:\n            return this.flowParseObjectType({\n              allowStatic: false,\n              allowExact: true,\n              allowSpread: true,\n              allowProto: false,\n              allowInexact: false\n            });\n\n          case types.bracketL:\n            this.state.noAnonFunctionType = false;\n            type = this.flowParseTupleType();\n            this.state.noAnonFunctionType = oldNoAnonFunctionType;\n            return type;\n\n          case types.relational:\n            if (this.state.value === \"<\") {\n              node.typeParameters = this.flowParseTypeParameterDeclaration();\n              this.expect(types.parenL);\n              tmp = this.flowParseFunctionTypeParams();\n              node.params = tmp.params;\n              node.rest = tmp.rest;\n              this.expect(types.parenR);\n              this.expect(types.arrow);\n              node.returnType = this.flowParseType();\n              return this.finishNode(node, \"FunctionTypeAnnotation\");\n            }\n\n            break;\n\n          case types.parenL:\n            this.next();\n\n            if (!this.match(types.parenR) && !this.match(types.ellipsis)) {\n              if (this.match(types.name)) {\n                var token = this.lookahead().type;\n                isGroupedType = token !== types.question && token !== types.colon;\n              } else {\n                isGroupedType = true;\n              }\n            }\n\n            if (isGroupedType) {\n              this.state.noAnonFunctionType = false;\n              type = this.flowParseType();\n              this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n              if (this.state.noAnonFunctionType || !(this.match(types.comma) || this.match(types.parenR) && this.lookahead().type === types.arrow)) {\n                this.expect(types.parenR);\n                return type;\n              } else {\n                this.eat(types.comma);\n              }\n            }\n\n            if (type) {\n              tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);\n            } else {\n              tmp = this.flowParseFunctionTypeParams();\n            }\n\n            node.params = tmp.params;\n            node.rest = tmp.rest;\n            this.expect(types.parenR);\n            this.expect(types.arrow);\n            node.returnType = this.flowParseType();\n            node.typeParameters = null;\n            return this.finishNode(node, \"FunctionTypeAnnotation\");\n\n          case types.string:\n            return this.parseLiteral(this.state.value, \"StringLiteralTypeAnnotation\");\n\n          case types._true:\n          case types._false:\n            node.value = this.match(types._true);\n            this.next();\n            return this.finishNode(node, \"BooleanLiteralTypeAnnotation\");\n\n          case types.plusMin:\n            if (this.state.value === \"-\") {\n              this.next();\n\n              if (this.match(types.num)) {\n                return this.parseLiteral(-this.state.value, \"NumberLiteralTypeAnnotation\", node.start, node.loc.start);\n              }\n\n              if (this.match(types.bigint)) {\n                return this.parseLiteral(-this.state.value, \"BigIntLiteralTypeAnnotation\", node.start, node.loc.start);\n              }\n\n              throw this.raise(this.state.start, FlowErrors.UnexpectedSubtractionOperand);\n            }\n\n            throw this.unexpected();\n\n          case types.num:\n            return this.parseLiteral(this.state.value, \"NumberLiteralTypeAnnotation\");\n\n          case types.bigint:\n            return this.parseLiteral(this.state.value, \"BigIntLiteralTypeAnnotation\");\n\n          case types._void:\n            this.next();\n            return this.finishNode(node, \"VoidTypeAnnotation\");\n\n          case types._null:\n            this.next();\n            return this.finishNode(node, \"NullLiteralTypeAnnotation\");\n\n          case types._this:\n            this.next();\n            return this.finishNode(node, \"ThisTypeAnnotation\");\n\n          case types.star:\n            this.next();\n            return this.finishNode(node, \"ExistsTypeAnnotation\");\n\n          default:\n            if (this.state.type.keyword === \"typeof\") {\n              return this.flowParseTypeofType();\n            } else if (this.state.type.keyword) {\n              var label = this.state.type.label;\n              this.next();\n              return _get(_getPrototypeOf(_class2.prototype), \"createIdentifier\", this).call(this, node, label);\n            }\n\n        }\n\n        throw this.unexpected();\n      }\n    }, {\n      key: \"flowParsePostfixType\",\n      value: function flowParsePostfixType() {\n        var startPos = this.state.start,\n            startLoc = this.state.startLoc;\n        var type = this.flowParsePrimaryType();\n\n        while (this.match(types.bracketL) && !this.canInsertSemicolon()) {\n          var node = this.startNodeAt(startPos, startLoc);\n          node.elementType = type;\n          this.expect(types.bracketL);\n          this.expect(types.bracketR);\n          type = this.finishNode(node, \"ArrayTypeAnnotation\");\n        }\n\n        return type;\n      }\n    }, {\n      key: \"flowParsePrefixType\",\n      value: function flowParsePrefixType() {\n        var node = this.startNode();\n\n        if (this.eat(types.question)) {\n          node.typeAnnotation = this.flowParsePrefixType();\n          return this.finishNode(node, \"NullableTypeAnnotation\");\n        } else {\n          return this.flowParsePostfixType();\n        }\n      }\n    }, {\n      key: \"flowParseAnonFunctionWithoutParens\",\n      value: function flowParseAnonFunctionWithoutParens() {\n        var param = this.flowParsePrefixType();\n\n        if (!this.state.noAnonFunctionType && this.eat(types.arrow)) {\n          var node = this.startNodeAt(param.start, param.loc.start);\n          node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];\n          node.rest = null;\n          node.returnType = this.flowParseType();\n          node.typeParameters = null;\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n        }\n\n        return param;\n      }\n    }, {\n      key: \"flowParseIntersectionType\",\n      value: function flowParseIntersectionType() {\n        var node = this.startNode();\n        this.eat(types.bitwiseAND);\n        var type = this.flowParseAnonFunctionWithoutParens();\n        node.types = [type];\n\n        while (this.eat(types.bitwiseAND)) {\n          node.types.push(this.flowParseAnonFunctionWithoutParens());\n        }\n\n        return node.types.length === 1 ? type : this.finishNode(node, \"IntersectionTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseUnionType\",\n      value: function flowParseUnionType() {\n        var node = this.startNode();\n        this.eat(types.bitwiseOR);\n        var type = this.flowParseIntersectionType();\n        node.types = [type];\n\n        while (this.eat(types.bitwiseOR)) {\n          node.types.push(this.flowParseIntersectionType());\n        }\n\n        return node.types.length === 1 ? type : this.finishNode(node, \"UnionTypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseType\",\n      value: function flowParseType() {\n        var oldInType = this.state.inType;\n        this.state.inType = true;\n        var type = this.flowParseUnionType();\n        this.state.inType = oldInType;\n        this.state.exprAllowed = this.state.exprAllowed || this.state.noAnonFunctionType;\n        return type;\n      }\n    }, {\n      key: \"flowParseTypeOrImplicitInstantiation\",\n      value: function flowParseTypeOrImplicitInstantiation() {\n        if (this.state.type === types.name && this.state.value === \"_\") {\n          var startPos = this.state.start;\n          var startLoc = this.state.startLoc;\n          var node = this.parseIdentifier();\n          return this.flowParseGenericType(startPos, startLoc, node);\n        } else {\n          return this.flowParseType();\n        }\n      }\n    }, {\n      key: \"flowParseTypeAnnotation\",\n      value: function flowParseTypeAnnotation() {\n        var node = this.startNode();\n        node.typeAnnotation = this.flowParseTypeInitialiser();\n        return this.finishNode(node, \"TypeAnnotation\");\n      }\n    }, {\n      key: \"flowParseTypeAnnotatableIdentifier\",\n      value: function flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {\n        var ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();\n\n        if (this.match(types.colon)) {\n          ident.typeAnnotation = this.flowParseTypeAnnotation();\n          this.resetEndLocation(ident);\n        }\n\n        return ident;\n      }\n    }, {\n      key: \"typeCastToParameter\",\n      value: function typeCastToParameter(node) {\n        node.expression.typeAnnotation = node.typeAnnotation;\n        this.resetEndLocation(node.expression, node.typeAnnotation.end, node.typeAnnotation.loc.end);\n        return node.expression;\n      }\n    }, {\n      key: \"flowParseVariance\",\n      value: function flowParseVariance() {\n        var variance = null;\n\n        if (this.match(types.plusMin)) {\n          variance = this.startNode();\n\n          if (this.state.value === \"+\") {\n            variance.kind = \"plus\";\n          } else {\n            variance.kind = \"minus\";\n          }\n\n          this.next();\n          this.finishNode(variance, \"Variance\");\n        }\n\n        return variance;\n      }\n    }, {\n      key: \"parseFunctionBody\",\n      value: function parseFunctionBody(node, allowExpressionBody) {\n        var _this5 = this;\n\n        var isMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n        if (allowExpressionBody) {\n          return this.forwardNoArrowParamsConversionAt(node, function () {\n            return _get(_getPrototypeOf(_class2.prototype), \"parseFunctionBody\", _this5).call(_this5, node, true, isMethod);\n          });\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseFunctionBody\", this).call(this, node, false, isMethod);\n      }\n    }, {\n      key: \"parseFunctionBodyAndFinish\",\n      value: function parseFunctionBodyAndFinish(node, type) {\n        var isMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n        if (this.match(types.colon)) {\n          var typeNode = this.startNode();\n\n          var _this$flowParseTypeAn3 = this.flowParseTypeAndPredicateInitialiser();\n\n          var _this$flowParseTypeAn4 = _slicedToArray(_this$flowParseTypeAn3, 2);\n\n          typeNode.typeAnnotation = _this$flowParseTypeAn4[0];\n          node.predicate = _this$flowParseTypeAn4[1];\n          node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, \"TypeAnnotation\") : null;\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"parseFunctionBodyAndFinish\", this).call(this, node, type, isMethod);\n      }\n    }, {\n      key: \"parseStatement\",\n      value: function parseStatement(context, topLevel) {\n        if (this.state.strict && this.match(types.name) && this.state.value === \"interface\") {\n          var node = this.startNode();\n          this.next();\n          return this.flowParseInterface(node);\n        } else if (this.shouldParseEnums() && this.isContextual(\"enum\")) {\n          var _node = this.startNode();\n\n          this.next();\n          return this.flowParseEnumDeclaration(_node);\n        } else {\n          var stmt = _get(_getPrototypeOf(_class2.prototype), \"parseStatement\", this).call(this, context, topLevel);\n\n          if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {\n            this.flowPragma = null;\n          }\n\n          return stmt;\n        }\n      }\n    }, {\n      key: \"parseExpressionStatement\",\n      value: function parseExpressionStatement(node, expr) {\n        if (expr.type === \"Identifier\") {\n          if (expr.name === \"declare\") {\n            if (this.match(types._class) || this.match(types.name) || this.match(types._function) || this.match(types._var) || this.match(types._export)) {\n              return this.flowParseDeclare(node);\n            }\n          } else if (this.match(types.name)) {\n            if (expr.name === \"interface\") {\n              return this.flowParseInterface(node);\n            } else if (expr.name === \"type\") {\n              return this.flowParseTypeAlias(node);\n            } else if (expr.name === \"opaque\") {\n              return this.flowParseOpaqueType(node, false);\n            }\n          }\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseExpressionStatement\", this).call(this, node, expr);\n      }\n    }, {\n      key: \"shouldParseExportDeclaration\",\n      value: function shouldParseExportDeclaration() {\n        return this.isContextual(\"type\") || this.isContextual(\"interface\") || this.isContextual(\"opaque\") || this.shouldParseEnums() && this.isContextual(\"enum\") || _get(_getPrototypeOf(_class2.prototype), \"shouldParseExportDeclaration\", this).call(this);\n      }\n    }, {\n      key: \"isExportDefaultSpecifier\",\n      value: function isExportDefaultSpecifier() {\n        if (this.match(types.name) && (this.state.value === \"type\" || this.state.value === \"interface\" || this.state.value === \"opaque\" || this.shouldParseEnums() && this.state.value === \"enum\")) {\n          return false;\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"isExportDefaultSpecifier\", this).call(this);\n      }\n    }, {\n      key: \"parseExportDefaultExpression\",\n      value: function parseExportDefaultExpression() {\n        if (this.shouldParseEnums() && this.isContextual(\"enum\")) {\n          var node = this.startNode();\n          this.next();\n          return this.flowParseEnumDeclaration(node);\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseExportDefaultExpression\", this).call(this);\n      }\n    }, {\n      key: \"parseConditional\",\n      value: function parseConditional(expr, startPos, startLoc, refNeedsArrowPos) {\n        var _this6 = this;\n\n        if (!this.match(types.question)) return expr;\n\n        if (refNeedsArrowPos) {\n          var result = this.tryParse(function () {\n            return _get(_getPrototypeOf(_class2.prototype), \"parseConditional\", _this6).call(_this6, expr, startPos, startLoc);\n          });\n\n          if (!result.node) {\n            refNeedsArrowPos.start = result.error.pos || this.state.start;\n            return expr;\n          }\n\n          if (result.error) this.state = result.failState;\n          return result.node;\n        }\n\n        this.expect(types.question);\n        var state = this.state.clone();\n        var originalNoArrowAt = this.state.noArrowAt;\n        var node = this.startNodeAt(startPos, startLoc);\n\n        var _this$tryParseConditi = this.tryParseConditionalConsequent(),\n            consequent = _this$tryParseConditi.consequent,\n            failed = _this$tryParseConditi.failed;\n\n        var _this$getArrowLikeExp = this.getArrowLikeExpressions(consequent),\n            _this$getArrowLikeExp2 = _slicedToArray(_this$getArrowLikeExp, 2),\n            valid = _this$getArrowLikeExp2[0],\n            invalid = _this$getArrowLikeExp2[1];\n\n        if (failed || invalid.length > 0) {\n          var noArrowAt = _toConsumableArray(originalNoArrowAt);\n\n          if (invalid.length > 0) {\n            this.state = state;\n            this.state.noArrowAt = noArrowAt;\n\n            for (var i = 0; i < invalid.length; i++) {\n              noArrowAt.push(invalid[i].start);\n            }\n\n            var _this$tryParseConditi2 = this.tryParseConditionalConsequent();\n\n            consequent = _this$tryParseConditi2.consequent;\n            failed = _this$tryParseConditi2.failed;\n\n            var _this$getArrowLikeExp3 = this.getArrowLikeExpressions(consequent);\n\n            var _this$getArrowLikeExp4 = _slicedToArray(_this$getArrowLikeExp3, 2);\n\n            valid = _this$getArrowLikeExp4[0];\n            invalid = _this$getArrowLikeExp4[1];\n          }\n\n          if (failed && valid.length > 1) {\n            this.raise(state.start, FlowErrors.AmbiguousConditionalArrow);\n          }\n\n          if (failed && valid.length === 1) {\n            this.state = state;\n            this.state.noArrowAt = noArrowAt.concat(valid[0].start);\n\n            var _this$tryParseConditi3 = this.tryParseConditionalConsequent();\n\n            consequent = _this$tryParseConditi3.consequent;\n            failed = _this$tryParseConditi3.failed;\n          }\n        }\n\n        this.getArrowLikeExpressions(consequent, true);\n        this.state.noArrowAt = originalNoArrowAt;\n        this.expect(types.colon);\n        node.test = expr;\n        node.consequent = consequent;\n        node.alternate = this.forwardNoArrowParamsConversionAt(node, function () {\n          return _this6.parseMaybeAssign(undefined, undefined, undefined);\n        });\n        return this.finishNode(node, \"ConditionalExpression\");\n      }\n    }, {\n      key: \"tryParseConditionalConsequent\",\n      value: function tryParseConditionalConsequent() {\n        this.state.noArrowParamsConversionAt.push(this.state.start);\n        var consequent = this.parseMaybeAssignAllowIn();\n        var failed = !this.match(types.colon);\n        this.state.noArrowParamsConversionAt.pop();\n        return {\n          consequent: consequent,\n          failed: failed\n        };\n      }\n    }, {\n      key: \"getArrowLikeExpressions\",\n      value: function getArrowLikeExpressions(node, disallowInvalid) {\n        var _this7 = this;\n\n        var stack = [node];\n        var arrows = [];\n\n        while (stack.length !== 0) {\n          var _node2 = stack.pop();\n\n          if (_node2.type === \"ArrowFunctionExpression\") {\n            if (_node2.typeParameters || !_node2.returnType) {\n              this.finishArrowValidation(_node2);\n            } else {\n              arrows.push(_node2);\n            }\n\n            stack.push(_node2.body);\n          } else if (_node2.type === \"ConditionalExpression\") {\n            stack.push(_node2.consequent);\n            stack.push(_node2.alternate);\n          }\n        }\n\n        if (disallowInvalid) {\n          arrows.forEach(function (node) {\n            return _this7.finishArrowValidation(node);\n          });\n          return [arrows, []];\n        }\n\n        return partition(arrows, function (node) {\n          return node.params.every(function (param) {\n            return _this7.isAssignable(param, true);\n          });\n        });\n      }\n    }, {\n      key: \"finishArrowValidation\",\n      value: function finishArrowValidation(node) {\n        var _node$extra;\n\n        this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingComma);\n        this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);\n\n        _get(_getPrototypeOf(_class2.prototype), \"checkParams\", this).call(this, node, false, true);\n\n        this.scope.exit();\n      }\n    }, {\n      key: \"forwardNoArrowParamsConversionAt\",\n      value: function forwardNoArrowParamsConversionAt(node, parse) {\n        var result;\n\n        if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n          this.state.noArrowParamsConversionAt.push(this.state.start);\n          result = parse();\n          this.state.noArrowParamsConversionAt.pop();\n        } else {\n          result = parse();\n        }\n\n        return result;\n      }\n    }, {\n      key: \"parseParenItem\",\n      value: function parseParenItem(node, startPos, startLoc) {\n        node = _get(_getPrototypeOf(_class2.prototype), \"parseParenItem\", this).call(this, node, startPos, startLoc);\n\n        if (this.eat(types.question)) {\n          node.optional = true;\n          this.resetEndLocation(node);\n        }\n\n        if (this.match(types.colon)) {\n          var typeCastNode = this.startNodeAt(startPos, startLoc);\n          typeCastNode.expression = node;\n          typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();\n          return this.finishNode(typeCastNode, \"TypeCastExpression\");\n        }\n\n        return node;\n      }\n    }, {\n      key: \"assertModuleNodeAllowed\",\n      value: function assertModuleNodeAllowed(node) {\n        if (node.type === \"ImportDeclaration\" && (node.importKind === \"type\" || node.importKind === \"typeof\") || node.type === \"ExportNamedDeclaration\" && node.exportKind === \"type\" || node.type === \"ExportAllDeclaration\" && node.exportKind === \"type\") {\n          return;\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"assertModuleNodeAllowed\", this).call(this, node);\n      }\n    }, {\n      key: \"parseExport\",\n      value: function parseExport(node) {\n        var decl = _get(_getPrototypeOf(_class2.prototype), \"parseExport\", this).call(this, node);\n\n        if (decl.type === \"ExportNamedDeclaration\" || decl.type === \"ExportAllDeclaration\") {\n          decl.exportKind = decl.exportKind || \"value\";\n        }\n\n        return decl;\n      }\n    }, {\n      key: \"parseExportDeclaration\",\n      value: function parseExportDeclaration(node) {\n        if (this.isContextual(\"type\")) {\n          node.exportKind = \"type\";\n          var declarationNode = this.startNode();\n          this.next();\n\n          if (this.match(types.braceL)) {\n            node.specifiers = this.parseExportSpecifiers();\n            this.parseExportFrom(node);\n            return null;\n          } else {\n            return this.flowParseTypeAlias(declarationNode);\n          }\n        } else if (this.isContextual(\"opaque\")) {\n          node.exportKind = \"type\";\n\n          var _declarationNode = this.startNode();\n\n          this.next();\n          return this.flowParseOpaqueType(_declarationNode, false);\n        } else if (this.isContextual(\"interface\")) {\n          node.exportKind = \"type\";\n\n          var _declarationNode2 = this.startNode();\n\n          this.next();\n          return this.flowParseInterface(_declarationNode2);\n        } else if (this.shouldParseEnums() && this.isContextual(\"enum\")) {\n          node.exportKind = \"value\";\n\n          var _declarationNode3 = this.startNode();\n\n          this.next();\n          return this.flowParseEnumDeclaration(_declarationNode3);\n        } else {\n          return _get(_getPrototypeOf(_class2.prototype), \"parseExportDeclaration\", this).call(this, node);\n        }\n      }\n    }, {\n      key: \"eatExportStar\",\n      value: function eatExportStar(node) {\n        if (_get(_getPrototypeOf(_class2.prototype), \"eatExportStar\", this).apply(this, arguments)) return true;\n\n        if (this.isContextual(\"type\") && this.lookahead().type === types.star) {\n          node.exportKind = \"type\";\n          this.next();\n          this.next();\n          return true;\n        }\n\n        return false;\n      }\n    }, {\n      key: \"maybeParseExportNamespaceSpecifier\",\n      value: function maybeParseExportNamespaceSpecifier(node) {\n        var pos = this.state.start;\n\n        var hasNamespace = _get(_getPrototypeOf(_class2.prototype), \"maybeParseExportNamespaceSpecifier\", this).call(this, node);\n\n        if (hasNamespace && node.exportKind === \"type\") {\n          this.unexpected(pos);\n        }\n\n        return hasNamespace;\n      }\n    }, {\n      key: \"parseClassId\",\n      value: function parseClassId(node, isStatement, optionalId) {\n        _get(_getPrototypeOf(_class2.prototype), \"parseClassId\", this).call(this, node, isStatement, optionalId);\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n        }\n      }\n    }, {\n      key: \"parseClassMember\",\n      value: function parseClassMember(classBody, member, state, constructorAllowsSuper) {\n        var pos = this.state.start;\n\n        if (this.isContextual(\"declare\")) {\n          if (this.parseClassMemberFromModifier(classBody, member)) {\n            return;\n          }\n\n          member.declare = true;\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"parseClassMember\", this).call(this, classBody, member, state, constructorAllowsSuper);\n\n        if (member.declare) {\n          if (member.type !== \"ClassProperty\" && member.type !== \"ClassPrivateProperty\") {\n            this.raise(pos, FlowErrors.DeclareClassElement);\n          } else if (member.value) {\n            this.raise(member.value.start, FlowErrors.DeclareClassFieldInitializer);\n          }\n        }\n      }\n    }, {\n      key: \"getTokenFromCode\",\n      value: function getTokenFromCode(code) {\n        var next = this.input.charCodeAt(this.state.pos + 1);\n\n        if (code === 123 && next === 124) {\n          return this.finishOp(types.braceBarL, 2);\n        } else if (this.state.inType && (code === 62 || code === 60)) {\n          return this.finishOp(types.relational, 1);\n        } else if (this.state.inType && code === 63) {\n          return this.finishOp(types.question, 1);\n        } else if (isIteratorStart(code, next)) {\n          this.state.isIterator = true;\n          return _get(_getPrototypeOf(_class2.prototype), \"readWord\", this).call(this);\n        } else {\n          return _get(_getPrototypeOf(_class2.prototype), \"getTokenFromCode\", this).call(this, code);\n        }\n      }\n    }, {\n      key: \"isAssignable\",\n      value: function isAssignable(node, isBinding) {\n        var _this8 = this;\n\n        switch (node.type) {\n          case \"Identifier\":\n          case \"ObjectPattern\":\n          case \"ArrayPattern\":\n          case \"AssignmentPattern\":\n            return true;\n\n          case \"ObjectExpression\":\n            {\n              var _last = node.properties.length - 1;\n\n              return node.properties.every(function (prop, i) {\n                return prop.type !== \"ObjectMethod\" && (i === _last || prop.type === \"SpreadElement\") && _this8.isAssignable(prop);\n              });\n            }\n\n          case \"ObjectProperty\":\n            return this.isAssignable(node.value);\n\n          case \"SpreadElement\":\n            return this.isAssignable(node.argument);\n\n          case \"ArrayExpression\":\n            return node.elements.every(function (element) {\n              return _this8.isAssignable(element);\n            });\n\n          case \"AssignmentExpression\":\n            return node.operator === \"=\";\n\n          case \"ParenthesizedExpression\":\n          case \"TypeCastExpression\":\n            return this.isAssignable(node.expression);\n\n          case \"MemberExpression\":\n          case \"OptionalMemberExpression\":\n            return !isBinding;\n\n          default:\n            return false;\n        }\n      }\n    }, {\n      key: \"toAssignable\",\n      value: function toAssignable(node) {\n        if (node.type === \"TypeCastExpression\") {\n          return _get(_getPrototypeOf(_class2.prototype), \"toAssignable\", this).call(this, this.typeCastToParameter(node));\n        } else {\n          return _get(_getPrototypeOf(_class2.prototype), \"toAssignable\", this).call(this, node);\n        }\n      }\n    }, {\n      key: \"toAssignableList\",\n      value: function toAssignableList(exprList, trailingCommaPos) {\n        for (var i = 0; i < exprList.length; i++) {\n          var expr = exprList[i];\n\n          if ((expr == null ? void 0 : expr.type) === \"TypeCastExpression\") {\n            exprList[i] = this.typeCastToParameter(expr);\n          }\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"toAssignableList\", this).call(this, exprList, trailingCommaPos);\n      }\n    }, {\n      key: \"toReferencedList\",\n      value: function toReferencedList(exprList, isParenthesizedExpr) {\n        for (var i = 0; i < exprList.length; i++) {\n          var _expr$extra;\n\n          var expr = exprList[i];\n\n          if (expr && expr.type === \"TypeCastExpression\" && !((_expr$extra = expr.extra) == null ? void 0 : _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {\n            this.raise(expr.typeAnnotation.start, FlowErrors.TypeCastInPattern);\n          }\n        }\n\n        return exprList;\n      }\n    }, {\n      key: \"checkLVal\",\n      value: function checkLVal(expr) {\n        var bindingType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : BIND_NONE;\n        var checkClashes = arguments.length > 2 ? arguments[2] : undefined;\n        var contextDescription = arguments.length > 3 ? arguments[3] : undefined;\n\n        if (expr.type !== \"TypeCastExpression\") {\n          return _get(_getPrototypeOf(_class2.prototype), \"checkLVal\", this).call(this, expr, bindingType, checkClashes, contextDescription);\n        }\n      }\n    }, {\n      key: \"parseClassProperty\",\n      value: function parseClassProperty(node) {\n        if (this.match(types.colon)) {\n          node.typeAnnotation = this.flowParseTypeAnnotation();\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseClassProperty\", this).call(this, node);\n      }\n    }, {\n      key: \"parseClassPrivateProperty\",\n      value: function parseClassPrivateProperty(node) {\n        if (this.match(types.colon)) {\n          node.typeAnnotation = this.flowParseTypeAnnotation();\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseClassPrivateProperty\", this).call(this, node);\n      }\n    }, {\n      key: \"isClassMethod\",\n      value: function isClassMethod() {\n        return this.isRelational(\"<\") || _get(_getPrototypeOf(_class2.prototype), \"isClassMethod\", this).call(this);\n      }\n    }, {\n      key: \"isClassProperty\",\n      value: function isClassProperty() {\n        return this.match(types.colon) || _get(_getPrototypeOf(_class2.prototype), \"isClassProperty\", this).call(this);\n      }\n    }, {\n      key: \"isNonstaticConstructor\",\n      value: function isNonstaticConstructor(method) {\n        return !this.match(types.colon) && _get(_getPrototypeOf(_class2.prototype), \"isNonstaticConstructor\", this).call(this, method);\n      }\n    }, {\n      key: \"pushClassMethod\",\n      value: function pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n        if (method.variance) {\n          this.unexpected(method.variance.start);\n        }\n\n        delete method.variance;\n\n        if (this.isRelational(\"<\")) {\n          method.typeParameters = this.flowParseTypeParameterDeclaration();\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"pushClassMethod\", this).call(this, classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);\n      }\n    }, {\n      key: \"pushClassPrivateMethod\",\n      value: function pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n        if (method.variance) {\n          this.unexpected(method.variance.start);\n        }\n\n        delete method.variance;\n\n        if (this.isRelational(\"<\")) {\n          method.typeParameters = this.flowParseTypeParameterDeclaration();\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"pushClassPrivateMethod\", this).call(this, classBody, method, isGenerator, isAsync);\n      }\n    }, {\n      key: \"parseClassSuper\",\n      value: function parseClassSuper(node) {\n        _get(_getPrototypeOf(_class2.prototype), \"parseClassSuper\", this).call(this, node);\n\n        if (node.superClass && this.isRelational(\"<\")) {\n          node.superTypeParameters = this.flowParseTypeParameterInstantiation();\n        }\n\n        if (this.isContextual(\"implements\")) {\n          this.next();\n          var implemented = node.implements = [];\n\n          do {\n            var _node3 = this.startNode();\n\n            _node3.id = this.flowParseRestrictedIdentifier(true);\n\n            if (this.isRelational(\"<\")) {\n              _node3.typeParameters = this.flowParseTypeParameterInstantiation();\n            } else {\n              _node3.typeParameters = null;\n            }\n\n            implemented.push(this.finishNode(_node3, \"ClassImplements\"));\n          } while (this.eat(types.comma));\n        }\n      }\n    }, {\n      key: \"parsePropertyName\",\n      value: function parsePropertyName(node, isPrivateNameAllowed) {\n        var variance = this.flowParseVariance();\n\n        var key = _get(_getPrototypeOf(_class2.prototype), \"parsePropertyName\", this).call(this, node, isPrivateNameAllowed);\n\n        node.variance = variance;\n        return key;\n      }\n    }, {\n      key: \"parseObjPropValue\",\n      value: function parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n        if (prop.variance) {\n          this.unexpected(prop.variance.start);\n        }\n\n        delete prop.variance;\n        var typeParameters;\n\n        if (this.isRelational(\"<\") && !isAccessor) {\n          typeParameters = this.flowParseTypeParameterDeclaration();\n          if (!this.match(types.parenL)) this.unexpected();\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"parseObjPropValue\", this).call(this, prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);\n\n        if (typeParameters) {\n          (prop.value || prop).typeParameters = typeParameters;\n        }\n      }\n    }, {\n      key: \"parseAssignableListItemTypes\",\n      value: function parseAssignableListItemTypes(param) {\n        if (this.eat(types.question)) {\n          if (param.type !== \"Identifier\") {\n            this.raise(param.start, FlowErrors.OptionalBindingPattern);\n          }\n\n          param.optional = true;\n        }\n\n        if (this.match(types.colon)) {\n          param.typeAnnotation = this.flowParseTypeAnnotation();\n        }\n\n        this.resetEndLocation(param);\n        return param;\n      }\n    }, {\n      key: \"parseMaybeDefault\",\n      value: function parseMaybeDefault(startPos, startLoc, left) {\n        var node = _get(_getPrototypeOf(_class2.prototype), \"parseMaybeDefault\", this).call(this, startPos, startLoc, left);\n\n        if (node.type === \"AssignmentPattern\" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {\n          this.raise(node.typeAnnotation.start, FlowErrors.TypeBeforeInitializer);\n        }\n\n        return node;\n      }\n    }, {\n      key: \"shouldParseDefaultImport\",\n      value: function shouldParseDefaultImport(node) {\n        if (!hasTypeImportKind(node)) {\n          return _get(_getPrototypeOf(_class2.prototype), \"shouldParseDefaultImport\", this).call(this, node);\n        }\n\n        return isMaybeDefaultImport(this.state);\n      }\n    }, {\n      key: \"parseImportSpecifierLocal\",\n      value: function parseImportSpecifierLocal(node, specifier, type, contextDescription) {\n        specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();\n        this.checkLVal(specifier.local, BIND_LEXICAL, undefined, contextDescription);\n        node.specifiers.push(this.finishNode(specifier, type));\n      }\n    }, {\n      key: \"maybeParseDefaultImportSpecifier\",\n      value: function maybeParseDefaultImportSpecifier(node) {\n        node.importKind = \"value\";\n        var kind = null;\n\n        if (this.match(types._typeof)) {\n          kind = \"typeof\";\n        } else if (this.isContextual(\"type\")) {\n          kind = \"type\";\n        }\n\n        if (kind) {\n          var lh = this.lookahead();\n\n          if (kind === \"type\" && lh.type === types.star) {\n            this.unexpected(lh.start);\n          }\n\n          if (isMaybeDefaultImport(lh) || lh.type === types.braceL || lh.type === types.star) {\n            this.next();\n            node.importKind = kind;\n          }\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"maybeParseDefaultImportSpecifier\", this).call(this, node);\n      }\n    }, {\n      key: \"parseImportSpecifier\",\n      value: function parseImportSpecifier(node) {\n        var specifier = this.startNode();\n        var firstIdentLoc = this.state.start;\n        var firstIdent = this.parseIdentifier(true);\n        var specifierTypeKind = null;\n\n        if (firstIdent.name === \"type\") {\n          specifierTypeKind = \"type\";\n        } else if (firstIdent.name === \"typeof\") {\n          specifierTypeKind = \"typeof\";\n        }\n\n        var isBinding = false;\n\n        if (this.isContextual(\"as\") && !this.isLookaheadContextual(\"as\")) {\n          var as_ident = this.parseIdentifier(true);\n\n          if (specifierTypeKind !== null && !this.match(types.name) && !this.state.type.keyword) {\n            specifier.imported = as_ident;\n            specifier.importKind = specifierTypeKind;\n            specifier.local = as_ident.__clone();\n          } else {\n            specifier.imported = firstIdent;\n            specifier.importKind = null;\n            specifier.local = this.parseIdentifier();\n          }\n        } else if (specifierTypeKind !== null && (this.match(types.name) || this.state.type.keyword)) {\n          specifier.imported = this.parseIdentifier(true);\n          specifier.importKind = specifierTypeKind;\n\n          if (this.eatContextual(\"as\")) {\n            specifier.local = this.parseIdentifier();\n          } else {\n            isBinding = true;\n            specifier.local = specifier.imported.__clone();\n          }\n        } else {\n          isBinding = true;\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n          specifier.local = specifier.imported.__clone();\n        }\n\n        var nodeIsTypeImport = hasTypeImportKind(node);\n        var specifierIsTypeImport = hasTypeImportKind(specifier);\n\n        if (nodeIsTypeImport && specifierIsTypeImport) {\n          this.raise(firstIdentLoc, FlowErrors.ImportTypeShorthandOnlyInPureImport);\n        }\n\n        if (nodeIsTypeImport || specifierIsTypeImport) {\n          this.checkReservedType(specifier.local.name, specifier.local.start, true);\n        }\n\n        if (isBinding && !nodeIsTypeImport && !specifierIsTypeImport) {\n          this.checkReservedWord(specifier.local.name, specifier.start, true, true);\n        }\n\n        this.checkLVal(specifier.local, BIND_LEXICAL, undefined, \"import specifier\");\n        node.specifiers.push(this.finishNode(specifier, \"ImportSpecifier\"));\n      }\n    }, {\n      key: \"parseFunctionParams\",\n      value: function parseFunctionParams(node, allowModifiers) {\n        var kind = node.kind;\n\n        if (kind !== \"get\" && kind !== \"set\" && this.isRelational(\"<\")) {\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"parseFunctionParams\", this).call(this, node, allowModifiers);\n      }\n    }, {\n      key: \"parseVarId\",\n      value: function parseVarId(decl, kind) {\n        _get(_getPrototypeOf(_class2.prototype), \"parseVarId\", this).call(this, decl, kind);\n\n        if (this.match(types.colon)) {\n          decl.id.typeAnnotation = this.flowParseTypeAnnotation();\n          this.resetEndLocation(decl.id);\n        }\n      }\n    }, {\n      key: \"parseAsyncArrowFromCallExpression\",\n      value: function parseAsyncArrowFromCallExpression(node, call) {\n        if (this.match(types.colon)) {\n          var oldNoAnonFunctionType = this.state.noAnonFunctionType;\n          this.state.noAnonFunctionType = true;\n          node.returnType = this.flowParseTypeAnnotation();\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseAsyncArrowFromCallExpression\", this).call(this, node, call);\n      }\n    }, {\n      key: \"shouldParseAsyncArrow\",\n      value: function shouldParseAsyncArrow() {\n        return this.match(types.colon) || _get(_getPrototypeOf(_class2.prototype), \"shouldParseAsyncArrow\", this).call(this);\n      }\n    }, {\n      key: \"parseMaybeAssign\",\n      value: function parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {\n        var _this9 = this;\n\n        var _jsx;\n\n        var state = null;\n        var jsx;\n\n        if (this.hasPlugin(\"jsx\") && (this.match(types.jsxTagStart) || this.isRelational(\"<\"))) {\n          state = this.state.clone();\n          jsx = this.tryParse(function () {\n            return _get(_getPrototypeOf(_class2.prototype), \"parseMaybeAssign\", _this9).call(_this9, refExpressionErrors, afterLeftParse, refNeedsArrowPos);\n          }, state);\n          if (!jsx.error) return jsx.node;\n          var context = this.state.context;\n\n          if (context[context.length - 1] === types$1.j_oTag) {\n            context.length -= 2;\n          } else if (context[context.length - 1] === types$1.j_expr) {\n            context.length -= 1;\n          }\n        }\n\n        if (((_jsx = jsx) == null ? void 0 : _jsx.error) || this.isRelational(\"<\")) {\n          var _jsx2, _jsx3;\n\n          state = state || this.state.clone();\n          var typeParameters;\n          var arrow = this.tryParse(function (abort) {\n            var _arrowExpression$extr;\n\n            typeParameters = _this9.flowParseTypeParameterDeclaration();\n\n            var arrowExpression = _this9.forwardNoArrowParamsConversionAt(typeParameters, function () {\n              var result = _get(_getPrototypeOf(_class2.prototype), \"parseMaybeAssign\", _this9).call(_this9, refExpressionErrors, afterLeftParse, refNeedsArrowPos);\n\n              _this9.resetStartLocationFromNode(result, typeParameters);\n\n              return result;\n            });\n\n            if (arrowExpression.type !== \"ArrowFunctionExpression\" && ((_arrowExpression$extr = arrowExpression.extra) == null ? void 0 : _arrowExpression$extr.parenthesized)) {\n              abort();\n            }\n\n            var expr = _this9.maybeUnwrapTypeCastExpression(arrowExpression);\n\n            expr.typeParameters = typeParameters;\n\n            _this9.resetStartLocationFromNode(expr, typeParameters);\n\n            return arrowExpression;\n          }, state);\n          var arrowExpression = null;\n\n          if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === \"ArrowFunctionExpression\") {\n            if (!arrow.error && !arrow.aborted) {\n              if (arrow.node.async) {\n                this.raise(typeParameters.start, FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction);\n              }\n\n              return arrow.node;\n            }\n\n            arrowExpression = arrow.node;\n          }\n\n          if ((_jsx2 = jsx) == null ? void 0 : _jsx2.node) {\n            this.state = jsx.failState;\n            return jsx.node;\n          }\n\n          if (arrowExpression) {\n            this.state = arrow.failState;\n            return arrowExpression;\n          }\n\n          if ((_jsx3 = jsx) == null ? void 0 : _jsx3.thrown) throw jsx.error;\n          if (arrow.thrown) throw arrow.error;\n          throw this.raise(typeParameters.start, FlowErrors.UnexpectedTokenAfterTypeParameter);\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseMaybeAssign\", this).call(this, refExpressionErrors, afterLeftParse, refNeedsArrowPos);\n      }\n    }, {\n      key: \"parseArrow\",\n      value: function parseArrow(node) {\n        var _this10 = this;\n\n        if (this.match(types.colon)) {\n          var result = this.tryParse(function () {\n            var oldNoAnonFunctionType = _this10.state.noAnonFunctionType;\n            _this10.state.noAnonFunctionType = true;\n\n            var typeNode = _this10.startNode();\n\n            var _this10$flowParseType = _this10.flowParseTypeAndPredicateInitialiser();\n\n            var _this10$flowParseType2 = _slicedToArray(_this10$flowParseType, 2);\n\n            typeNode.typeAnnotation = _this10$flowParseType2[0];\n            node.predicate = _this10$flowParseType2[1];\n            _this10.state.noAnonFunctionType = oldNoAnonFunctionType;\n            if (_this10.canInsertSemicolon()) _this10.unexpected();\n            if (!_this10.match(types.arrow)) _this10.unexpected();\n            return typeNode;\n          });\n          if (result.thrown) return null;\n          if (result.error) this.state = result.failState;\n          node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, \"TypeAnnotation\") : null;\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseArrow\", this).call(this, node);\n      }\n    }, {\n      key: \"shouldParseArrow\",\n      value: function shouldParseArrow() {\n        return this.match(types.colon) || _get(_getPrototypeOf(_class2.prototype), \"shouldParseArrow\", this).call(this);\n      }\n    }, {\n      key: \"setArrowFunctionParameters\",\n      value: function setArrowFunctionParameters(node, params) {\n        if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n          node.params = params;\n        } else {\n          _get(_getPrototypeOf(_class2.prototype), \"setArrowFunctionParameters\", this).call(this, node, params);\n        }\n      }\n    }, {\n      key: \"checkParams\",\n      value: function checkParams(node, allowDuplicates, isArrowFunction) {\n        if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n          return;\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"checkParams\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseParenAndDistinguishExpression\",\n      value: function parseParenAndDistinguishExpression(canBeArrow) {\n        return _get(_getPrototypeOf(_class2.prototype), \"parseParenAndDistinguishExpression\", this).call(this, canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);\n      }\n    }, {\n      key: \"parseSubscripts\",\n      value: function parseSubscripts(base, startPos, startLoc, noCalls) {\n        var _this11 = this;\n\n        if (base.type === \"Identifier\" && base.name === \"async\" && this.state.noArrowAt.indexOf(startPos) !== -1) {\n          this.next();\n          var node = this.startNodeAt(startPos, startLoc);\n          node.callee = base;\n          node.arguments = this.parseCallExpressionArguments(types.parenR, false);\n          base = this.finishNode(node, \"CallExpression\");\n        } else if (base.type === \"Identifier\" && base.name === \"async\" && this.isRelational(\"<\")) {\n          var state = this.state.clone();\n          var arrow = this.tryParse(function (abort) {\n            return _this11.parseAsyncArrowWithTypeParameters(startPos, startLoc) || abort();\n          }, state);\n          if (!arrow.error && !arrow.aborted) return arrow.node;\n          var result = this.tryParse(function () {\n            return _get(_getPrototypeOf(_class2.prototype), \"parseSubscripts\", _this11).call(_this11, base, startPos, startLoc, noCalls);\n          }, state);\n          if (result.node && !result.error) return result.node;\n\n          if (arrow.node) {\n            this.state = arrow.failState;\n            return arrow.node;\n          }\n\n          if (result.node) {\n            this.state = result.failState;\n            return result.node;\n          }\n\n          throw arrow.error || result.error;\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseSubscripts\", this).call(this, base, startPos, startLoc, noCalls);\n      }\n    }, {\n      key: \"parseSubscript\",\n      value: function parseSubscript(base, startPos, startLoc, noCalls, subscriptState) {\n        var _this12 = this;\n\n        if (this.match(types.questionDot) && this.isLookaheadToken_lt()) {\n          subscriptState.optionalChainMember = true;\n\n          if (noCalls) {\n            subscriptState.stop = true;\n            return base;\n          }\n\n          this.next();\n          var node = this.startNodeAt(startPos, startLoc);\n          node.callee = base;\n          node.typeArguments = this.flowParseTypeParameterInstantiation();\n          this.expect(types.parenL);\n          node.arguments = this.parseCallExpressionArguments(types.parenR, false);\n          node.optional = true;\n          return this.finishCallExpression(node, true);\n        } else if (!noCalls && this.shouldParseTypes() && this.isRelational(\"<\")) {\n          var _node4 = this.startNodeAt(startPos, startLoc);\n\n          _node4.callee = base;\n          var result = this.tryParse(function () {\n            _node4.typeArguments = _this12.flowParseTypeParameterInstantiationCallOrNew();\n\n            _this12.expect(types.parenL);\n\n            _node4.arguments = _this12.parseCallExpressionArguments(types.parenR, false);\n            if (subscriptState.optionalChainMember) _node4.optional = false;\n            return _this12.finishCallExpression(_node4, subscriptState.optionalChainMember);\n          });\n\n          if (result.node) {\n            if (result.error) this.state = result.failState;\n            return result.node;\n          }\n        }\n\n        return _get(_getPrototypeOf(_class2.prototype), \"parseSubscript\", this).call(this, base, startPos, startLoc, noCalls, subscriptState);\n      }\n    }, {\n      key: \"parseNewArguments\",\n      value: function parseNewArguments(node) {\n        var _this13 = this;\n\n        var targs = null;\n\n        if (this.shouldParseTypes() && this.isRelational(\"<\")) {\n          targs = this.tryParse(function () {\n            return _this13.flowParseTypeParameterInstantiationCallOrNew();\n          }).node;\n        }\n\n        node.typeArguments = targs;\n\n        _get(_getPrototypeOf(_class2.prototype), \"parseNewArguments\", this).call(this, node);\n      }\n    }, {\n      key: \"parseAsyncArrowWithTypeParameters\",\n      value: function parseAsyncArrowWithTypeParameters(startPos, startLoc) {\n        var node = this.startNodeAt(startPos, startLoc);\n        this.parseFunctionParams(node);\n        if (!this.parseArrow(node)) return;\n        return this.parseArrowExpression(node, undefined, true);\n      }\n    }, {\n      key: \"readToken_mult_modulo\",\n      value: function readToken_mult_modulo(code) {\n        var next = this.input.charCodeAt(this.state.pos + 1);\n\n        if (code === 42 && next === 47 && this.state.hasFlowComment) {\n          this.state.hasFlowComment = false;\n          this.state.pos += 2;\n          this.nextToken();\n          return;\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"readToken_mult_modulo\", this).call(this, code);\n      }\n    }, {\n      key: \"readToken_pipe_amp\",\n      value: function readToken_pipe_amp(code) {\n        var next = this.input.charCodeAt(this.state.pos + 1);\n\n        if (code === 124 && next === 125) {\n          this.finishOp(types.braceBarR, 2);\n          return;\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"readToken_pipe_amp\", this).call(this, code);\n      }\n    }, {\n      key: \"parseTopLevel\",\n      value: function parseTopLevel(file, program) {\n        var fileNode = _get(_getPrototypeOf(_class2.prototype), \"parseTopLevel\", this).call(this, file, program);\n\n        if (this.state.hasFlowComment) {\n          this.raise(this.state.pos, FlowErrors.UnterminatedFlowComment);\n        }\n\n        return fileNode;\n      }\n    }, {\n      key: \"skipBlockComment\",\n      value: function skipBlockComment() {\n        if (this.hasPlugin(\"flowComments\") && this.skipFlowComment()) {\n          if (this.state.hasFlowComment) {\n            this.unexpected(null, FlowErrors.NestedFlowComment);\n          }\n\n          this.hasFlowCommentCompletion();\n          this.state.pos += this.skipFlowComment();\n          this.state.hasFlowComment = true;\n          return;\n        }\n\n        if (this.state.hasFlowComment) {\n          var end = this.input.indexOf(\"*-/\", this.state.pos += 2);\n\n          if (end === -1) {\n            throw this.raise(this.state.pos - 2, ErrorMessages.UnterminatedComment);\n          }\n\n          this.state.pos = end + 3;\n          return;\n        }\n\n        _get(_getPrototypeOf(_class2.prototype), \"skipBlockComment\", this).call(this);\n      }\n    }, {\n      key: \"skipFlowComment\",\n      value: function skipFlowComment() {\n        var pos = this.state.pos;\n        var shiftToFirstNonWhiteSpace = 2;\n\n        while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {\n          shiftToFirstNonWhiteSpace++;\n        }\n\n        var ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);\n        var ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);\n\n        if (ch2 === 58 && ch3 === 58) {\n          return shiftToFirstNonWhiteSpace + 2;\n        }\n\n        if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === \"flow-include\") {\n          return shiftToFirstNonWhiteSpace + 12;\n        }\n\n        if (ch2 === 58 && ch3 !== 58) {\n          return shiftToFirstNonWhiteSpace;\n        }\n\n        return false;\n      }\n    }, {\n      key: \"hasFlowCommentCompletion\",\n      value: function hasFlowCommentCompletion() {\n        var end = this.input.indexOf(\"*/\", this.state.pos);\n\n        if (end === -1) {\n          throw this.raise(this.state.pos, ErrorMessages.UnterminatedComment);\n        }\n      }\n    }, {\n      key: \"flowEnumErrorBooleanMemberNotInitialized\",\n      value: function flowEnumErrorBooleanMemberNotInitialized(pos, _ref3) {\n        var enumName = _ref3.enumName,\n            memberName = _ref3.memberName;\n        this.raise(pos, FlowErrors.EnumBooleanMemberNotInitialized, memberName, enumName);\n      }\n    }, {\n      key: \"flowEnumErrorInvalidMemberName\",\n      value: function flowEnumErrorInvalidMemberName(pos, _ref4) {\n        var enumName = _ref4.enumName,\n            memberName = _ref4.memberName;\n        var suggestion = memberName[0].toUpperCase() + memberName.slice(1);\n        this.raise(pos, FlowErrors.EnumInvalidMemberName, memberName, suggestion, enumName);\n      }\n    }, {\n      key: \"flowEnumErrorDuplicateMemberName\",\n      value: function flowEnumErrorDuplicateMemberName(pos, _ref5) {\n        var enumName = _ref5.enumName,\n            memberName = _ref5.memberName;\n        this.raise(pos, FlowErrors.EnumDuplicateMemberName, memberName, enumName);\n      }\n    }, {\n      key: \"flowEnumErrorInconsistentMemberValues\",\n      value: function flowEnumErrorInconsistentMemberValues(pos, _ref6) {\n        var enumName = _ref6.enumName;\n        this.raise(pos, FlowErrors.EnumInconsistentMemberValues, enumName);\n      }\n    }, {\n      key: \"flowEnumErrorInvalidExplicitType\",\n      value: function flowEnumErrorInvalidExplicitType(pos, _ref7) {\n        var enumName = _ref7.enumName,\n            suppliedType = _ref7.suppliedType;\n        return this.raise(pos, suppliedType === null ? FlowErrors.EnumInvalidExplicitTypeUnknownSupplied : FlowErrors.EnumInvalidExplicitType, enumName, suppliedType);\n      }\n    }, {\n      key: \"flowEnumErrorInvalidMemberInitializer\",\n      value: function flowEnumErrorInvalidMemberInitializer(pos, _ref8) {\n        var enumName = _ref8.enumName,\n            explicitType = _ref8.explicitType,\n            memberName = _ref8.memberName;\n        var message = null;\n\n        switch (explicitType) {\n          case \"boolean\":\n          case \"number\":\n          case \"string\":\n            message = FlowErrors.EnumInvalidMemberInitializerPrimaryType;\n            break;\n\n          case \"symbol\":\n            message = FlowErrors.EnumInvalidMemberInitializerSymbolType;\n            break;\n\n          default:\n            message = FlowErrors.EnumInvalidMemberInitializerUnknownType;\n        }\n\n        return this.raise(pos, message, enumName, memberName, explicitType);\n      }\n    }, {\n      key: \"flowEnumErrorNumberMemberNotInitialized\",\n      value: function flowEnumErrorNumberMemberNotInitialized(pos, _ref9) {\n        var enumName = _ref9.enumName,\n            memberName = _ref9.memberName;\n        this.raise(pos, FlowErrors.EnumNumberMemberNotInitialized, enumName, memberName);\n      }\n    }, {\n      key: \"flowEnumErrorStringMemberInconsistentlyInitailized\",\n      value: function flowEnumErrorStringMemberInconsistentlyInitailized(pos, _ref10) {\n        var enumName = _ref10.enumName;\n        this.raise(pos, FlowErrors.EnumStringMemberInconsistentlyInitailized, enumName);\n      }\n    }, {\n      key: \"flowEnumMemberInit\",\n      value: function flowEnumMemberInit() {\n        var _this14 = this;\n\n        var startPos = this.state.start;\n\n        var endOfInit = function endOfInit() {\n          return _this14.match(types.comma) || _this14.match(types.braceR);\n        };\n\n        switch (this.state.type) {\n          case types.num:\n            {\n              var literal = this.parseLiteral(this.state.value, \"NumericLiteral\");\n\n              if (endOfInit()) {\n                return {\n                  type: \"number\",\n                  pos: literal.start,\n                  value: literal\n                };\n              }\n\n              return {\n                type: \"invalid\",\n                pos: startPos\n              };\n            }\n\n          case types.string:\n            {\n              var _literal = this.parseLiteral(this.state.value, \"StringLiteral\");\n\n              if (endOfInit()) {\n                return {\n                  type: \"string\",\n                  pos: _literal.start,\n                  value: _literal\n                };\n              }\n\n              return {\n                type: \"invalid\",\n                pos: startPos\n              };\n            }\n\n          case types._true:\n          case types._false:\n            {\n              var _literal2 = this.parseBooleanLiteral();\n\n              if (endOfInit()) {\n                return {\n                  type: \"boolean\",\n                  pos: _literal2.start,\n                  value: _literal2\n                };\n              }\n\n              return {\n                type: \"invalid\",\n                pos: startPos\n              };\n            }\n\n          default:\n            return {\n              type: \"invalid\",\n              pos: startPos\n            };\n        }\n      }\n    }, {\n      key: \"flowEnumMemberRaw\",\n      value: function flowEnumMemberRaw() {\n        var pos = this.state.start;\n        var id = this.parseIdentifier(true);\n        var init = this.eat(types.eq) ? this.flowEnumMemberInit() : {\n          type: \"none\",\n          pos: pos\n        };\n        return {\n          id: id,\n          init: init\n        };\n      }\n    }, {\n      key: \"flowEnumCheckExplicitTypeMismatch\",\n      value: function flowEnumCheckExplicitTypeMismatch(pos, context, expectedType) {\n        var explicitType = context.explicitType;\n\n        if (explicitType === null) {\n          return;\n        }\n\n        if (explicitType !== expectedType) {\n          this.flowEnumErrorInvalidMemberInitializer(pos, context);\n        }\n      }\n    }, {\n      key: \"flowEnumMembers\",\n      value: function flowEnumMembers(_ref11) {\n        var enumName = _ref11.enumName,\n            explicitType = _ref11.explicitType;\n        var seenNames = new Set();\n        var members = {\n          booleanMembers: [],\n          numberMembers: [],\n          stringMembers: [],\n          defaultedMembers: []\n        };\n\n        while (!this.match(types.braceR)) {\n          var memberNode = this.startNode();\n\n          var _this$flowEnumMemberR = this.flowEnumMemberRaw(),\n              id = _this$flowEnumMemberR.id,\n              init = _this$flowEnumMemberR.init;\n\n          var memberName = id.name;\n\n          if (memberName === \"\") {\n            continue;\n          }\n\n          if (/^[a-z]/.test(memberName)) {\n            this.flowEnumErrorInvalidMemberName(id.start, {\n              enumName: enumName,\n              memberName: memberName\n            });\n          }\n\n          if (seenNames.has(memberName)) {\n            this.flowEnumErrorDuplicateMemberName(id.start, {\n              enumName: enumName,\n              memberName: memberName\n            });\n          }\n\n          seenNames.add(memberName);\n          var context = {\n            enumName: enumName,\n            explicitType: explicitType,\n            memberName: memberName\n          };\n          memberNode.id = id;\n\n          switch (init.type) {\n            case \"boolean\":\n              {\n                this.flowEnumCheckExplicitTypeMismatch(init.pos, context, \"boolean\");\n                memberNode.init = init.value;\n                members.booleanMembers.push(this.finishNode(memberNode, \"EnumBooleanMember\"));\n                break;\n              }\n\n            case \"number\":\n              {\n                this.flowEnumCheckExplicitTypeMismatch(init.pos, context, \"number\");\n                memberNode.init = init.value;\n                members.numberMembers.push(this.finishNode(memberNode, \"EnumNumberMember\"));\n                break;\n              }\n\n            case \"string\":\n              {\n                this.flowEnumCheckExplicitTypeMismatch(init.pos, context, \"string\");\n                memberNode.init = init.value;\n                members.stringMembers.push(this.finishNode(memberNode, \"EnumStringMember\"));\n                break;\n              }\n\n            case \"invalid\":\n              {\n                throw this.flowEnumErrorInvalidMemberInitializer(init.pos, context);\n              }\n\n            case \"none\":\n              {\n                switch (explicitType) {\n                  case \"boolean\":\n                    this.flowEnumErrorBooleanMemberNotInitialized(init.pos, context);\n                    break;\n\n                  case \"number\":\n                    this.flowEnumErrorNumberMemberNotInitialized(init.pos, context);\n                    break;\n\n                  default:\n                    members.defaultedMembers.push(this.finishNode(memberNode, \"EnumDefaultedMember\"));\n                }\n              }\n          }\n\n          if (!this.match(types.braceR)) {\n            this.expect(types.comma);\n          }\n        }\n\n        return members;\n      }\n    }, {\n      key: \"flowEnumStringMembers\",\n      value: function flowEnumStringMembers(initializedMembers, defaultedMembers, _ref12) {\n        var enumName = _ref12.enumName;\n\n        if (initializedMembers.length === 0) {\n          return defaultedMembers;\n        } else if (defaultedMembers.length === 0) {\n          return initializedMembers;\n        } else if (defaultedMembers.length > initializedMembers.length) {\n          for (var _i = 0; _i < initializedMembers.length; _i++) {\n            var member = initializedMembers[_i];\n            this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {\n              enumName: enumName\n            });\n          }\n\n          return defaultedMembers;\n        } else {\n          for (var _i2 = 0; _i2 < defaultedMembers.length; _i2++) {\n            var _member = defaultedMembers[_i2];\n            this.flowEnumErrorStringMemberInconsistentlyInitailized(_member.start, {\n              enumName: enumName\n            });\n          }\n\n          return initializedMembers;\n        }\n      }\n    }, {\n      key: \"flowEnumParseExplicitType\",\n      value: function flowEnumParseExplicitType(_ref13) {\n        var enumName = _ref13.enumName;\n\n        if (this.eatContextual(\"of\")) {\n          if (!this.match(types.name)) {\n            throw this.flowEnumErrorInvalidExplicitType(this.state.start, {\n              enumName: enumName,\n              suppliedType: null\n            });\n          }\n\n          var value = this.state.value;\n          this.next();\n\n          if (value !== \"boolean\" && value !== \"number\" && value !== \"string\" && value !== \"symbol\") {\n            this.flowEnumErrorInvalidExplicitType(this.state.start, {\n              enumName: enumName,\n              suppliedType: value\n            });\n          }\n\n          return value;\n        }\n\n        return null;\n      }\n    }, {\n      key: \"flowEnumBody\",\n      value: function flowEnumBody(node, _ref14) {\n        var _this15 = this;\n\n        var enumName = _ref14.enumName,\n            nameLoc = _ref14.nameLoc;\n        var explicitType = this.flowEnumParseExplicitType({\n          enumName: enumName\n        });\n        this.expect(types.braceL);\n        var members = this.flowEnumMembers({\n          enumName: enumName,\n          explicitType: explicitType\n        });\n\n        switch (explicitType) {\n          case \"boolean\":\n            node.explicitType = true;\n            node.members = members.booleanMembers;\n            this.expect(types.braceR);\n            return this.finishNode(node, \"EnumBooleanBody\");\n\n          case \"number\":\n            node.explicitType = true;\n            node.members = members.numberMembers;\n            this.expect(types.braceR);\n            return this.finishNode(node, \"EnumNumberBody\");\n\n          case \"string\":\n            node.explicitType = true;\n            node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {\n              enumName: enumName\n            });\n            this.expect(types.braceR);\n            return this.finishNode(node, \"EnumStringBody\");\n\n          case \"symbol\":\n            node.members = members.defaultedMembers;\n            this.expect(types.braceR);\n            return this.finishNode(node, \"EnumSymbolBody\");\n\n          default:\n            {\n              var empty = function empty() {\n                node.members = [];\n\n                _this15.expect(types.braceR);\n\n                return _this15.finishNode(node, \"EnumStringBody\");\n              };\n\n              node.explicitType = false;\n              var boolsLen = members.booleanMembers.length;\n              var numsLen = members.numberMembers.length;\n              var strsLen = members.stringMembers.length;\n              var defaultedLen = members.defaultedMembers.length;\n\n              if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {\n                return empty();\n              } else if (!boolsLen && !numsLen) {\n                node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {\n                  enumName: enumName\n                });\n                this.expect(types.braceR);\n                return this.finishNode(node, \"EnumStringBody\");\n              } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {\n                for (var _i3 = 0, _members$defaultedMem = members.defaultedMembers; _i3 < _members$defaultedMem.length; _i3++) {\n                  var member = _members$defaultedMem[_i3];\n                  this.flowEnumErrorBooleanMemberNotInitialized(member.start, {\n                    enumName: enumName,\n                    memberName: member.id.name\n                  });\n                }\n\n                node.members = members.booleanMembers;\n                this.expect(types.braceR);\n                return this.finishNode(node, \"EnumBooleanBody\");\n              } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {\n                for (var _i4 = 0, _members$defaultedMem2 = members.defaultedMembers; _i4 < _members$defaultedMem2.length; _i4++) {\n                  var _member2 = _members$defaultedMem2[_i4];\n                  this.flowEnumErrorNumberMemberNotInitialized(_member2.start, {\n                    enumName: enumName,\n                    memberName: _member2.id.name\n                  });\n                }\n\n                node.members = members.numberMembers;\n                this.expect(types.braceR);\n                return this.finishNode(node, \"EnumNumberBody\");\n              } else {\n                this.flowEnumErrorInconsistentMemberValues(nameLoc, {\n                  enumName: enumName\n                });\n                return empty();\n              }\n            }\n        }\n      }\n    }, {\n      key: \"flowParseEnumDeclaration\",\n      value: function flowParseEnumDeclaration(node) {\n        var id = this.parseIdentifier();\n        node.id = id;\n        node.body = this.flowEnumBody(this.startNode(), {\n          enumName: id.name,\n          nameLoc: id.start\n        });\n        return this.finishNode(node, \"EnumDeclaration\");\n      }\n    }, {\n      key: \"updateContext\",\n      value: function updateContext(prevType) {\n        if (this.match(types.name) && this.state.value === \"of\" && prevType === types.name && this.input.slice(this.state.lastTokStart, this.state.lastTokEnd) === \"interface\") {\n          this.state.exprAllowed = false;\n        } else {\n          _get(_getPrototypeOf(_class2.prototype), \"updateContext\", this).call(this, prevType);\n        }\n      }\n    }, {\n      key: \"isLookaheadToken_lt\",\n      value: function isLookaheadToken_lt() {\n        var next = this.nextTokenStart();\n\n        if (this.input.charCodeAt(next) === 60) {\n          var afterNext = this.input.charCodeAt(next + 1);\n          return afterNext !== 60 && afterNext !== 61;\n        }\n\n        return false;\n      }\n    }, {\n      key: \"maybeUnwrapTypeCastExpression\",\n      value: function maybeUnwrapTypeCastExpression(node) {\n        return node.type === \"TypeCastExpression\" ? node.expression : node;\n      }\n    }]);\n\n    return _class2;\n  }(superClass);\n};\n\nvar entities = {\n  quot: \"\\\"\",\n  amp: \"&\",\n  apos: \"'\",\n  lt: \"<\",\n  gt: \">\",\n  nbsp: \"\\xA0\",\n  iexcl: \"\\xA1\",\n  cent: \"\\xA2\",\n  pound: \"\\xA3\",\n  curren: \"\\xA4\",\n  yen: \"\\xA5\",\n  brvbar: \"\\xA6\",\n  sect: \"\\xA7\",\n  uml: \"\\xA8\",\n  copy: \"\\xA9\",\n  ordf: \"\\xAA\",\n  laquo: \"\\xAB\",\n  not: \"\\xAC\",\n  shy: \"\\xAD\",\n  reg: \"\\xAE\",\n  macr: \"\\xAF\",\n  deg: \"\\xB0\",\n  plusmn: \"\\xB1\",\n  sup2: \"\\xB2\",\n  sup3: \"\\xB3\",\n  acute: \"\\xB4\",\n  micro: \"\\xB5\",\n  para: \"\\xB6\",\n  middot: \"\\xB7\",\n  cedil: \"\\xB8\",\n  sup1: \"\\xB9\",\n  ordm: \"\\xBA\",\n  raquo: \"\\xBB\",\n  frac14: \"\\xBC\",\n  frac12: \"\\xBD\",\n  frac34: \"\\xBE\",\n  iquest: \"\\xBF\",\n  Agrave: \"\\xC0\",\n  Aacute: \"\\xC1\",\n  Acirc: \"\\xC2\",\n  Atilde: \"\\xC3\",\n  Auml: \"\\xC4\",\n  Aring: \"\\xC5\",\n  AElig: \"\\xC6\",\n  Ccedil: \"\\xC7\",\n  Egrave: \"\\xC8\",\n  Eacute: \"\\xC9\",\n  Ecirc: \"\\xCA\",\n  Euml: \"\\xCB\",\n  Igrave: \"\\xCC\",\n  Iacute: \"\\xCD\",\n  Icirc: \"\\xCE\",\n  Iuml: \"\\xCF\",\n  ETH: \"\\xD0\",\n  Ntilde: \"\\xD1\",\n  Ograve: \"\\xD2\",\n  Oacute: \"\\xD3\",\n  Ocirc: \"\\xD4\",\n  Otilde: \"\\xD5\",\n  Ouml: \"\\xD6\",\n  times: \"\\xD7\",\n  Oslash: \"\\xD8\",\n  Ugrave: \"\\xD9\",\n  Uacute: \"\\xDA\",\n  Ucirc: \"\\xDB\",\n  Uuml: \"\\xDC\",\n  Yacute: \"\\xDD\",\n  THORN: \"\\xDE\",\n  szlig: \"\\xDF\",\n  agrave: \"\\xE0\",\n  aacute: \"\\xE1\",\n  acirc: \"\\xE2\",\n  atilde: \"\\xE3\",\n  auml: \"\\xE4\",\n  aring: \"\\xE5\",\n  aelig: \"\\xE6\",\n  ccedil: \"\\xE7\",\n  egrave: \"\\xE8\",\n  eacute: \"\\xE9\",\n  ecirc: \"\\xEA\",\n  euml: \"\\xEB\",\n  igrave: \"\\xEC\",\n  iacute: \"\\xED\",\n  icirc: \"\\xEE\",\n  iuml: \"\\xEF\",\n  eth: \"\\xF0\",\n  ntilde: \"\\xF1\",\n  ograve: \"\\xF2\",\n  oacute: \"\\xF3\",\n  ocirc: \"\\xF4\",\n  otilde: \"\\xF5\",\n  ouml: \"\\xF6\",\n  divide: \"\\xF7\",\n  oslash: \"\\xF8\",\n  ugrave: \"\\xF9\",\n  uacute: \"\\xFA\",\n  ucirc: \"\\xFB\",\n  uuml: \"\\xFC\",\n  yacute: \"\\xFD\",\n  thorn: \"\\xFE\",\n  yuml: \"\\xFF\",\n  OElig: \"\\u0152\",\n  oelig: \"\\u0153\",\n  Scaron: \"\\u0160\",\n  scaron: \"\\u0161\",\n  Yuml: \"\\u0178\",\n  fnof: \"\\u0192\",\n  circ: \"\\u02C6\",\n  tilde: \"\\u02DC\",\n  Alpha: \"\\u0391\",\n  Beta: \"\\u0392\",\n  Gamma: \"\\u0393\",\n  Delta: \"\\u0394\",\n  Epsilon: \"\\u0395\",\n  Zeta: \"\\u0396\",\n  Eta: \"\\u0397\",\n  Theta: \"\\u0398\",\n  Iota: \"\\u0399\",\n  Kappa: \"\\u039A\",\n  Lambda: \"\\u039B\",\n  Mu: \"\\u039C\",\n  Nu: \"\\u039D\",\n  Xi: \"\\u039E\",\n  Omicron: \"\\u039F\",\n  Pi: \"\\u03A0\",\n  Rho: \"\\u03A1\",\n  Sigma: \"\\u03A3\",\n  Tau: \"\\u03A4\",\n  Upsilon: \"\\u03A5\",\n  Phi: \"\\u03A6\",\n  Chi: \"\\u03A7\",\n  Psi: \"\\u03A8\",\n  Omega: \"\\u03A9\",\n  alpha: \"\\u03B1\",\n  beta: \"\\u03B2\",\n  gamma: \"\\u03B3\",\n  delta: \"\\u03B4\",\n  epsilon: \"\\u03B5\",\n  zeta: \"\\u03B6\",\n  eta: \"\\u03B7\",\n  theta: \"\\u03B8\",\n  iota: \"\\u03B9\",\n  kappa: \"\\u03BA\",\n  lambda: \"\\u03BB\",\n  mu: \"\\u03BC\",\n  nu: \"\\u03BD\",\n  xi: \"\\u03BE\",\n  omicron: \"\\u03BF\",\n  pi: \"\\u03C0\",\n  rho: \"\\u03C1\",\n  sigmaf: \"\\u03C2\",\n  sigma: \"\\u03C3\",\n  tau: \"\\u03C4\",\n  upsilon: \"\\u03C5\",\n  phi: \"\\u03C6\",\n  chi: \"\\u03C7\",\n  psi: \"\\u03C8\",\n  omega: \"\\u03C9\",\n  thetasym: \"\\u03D1\",\n  upsih: \"\\u03D2\",\n  piv: \"\\u03D6\",\n  ensp: \"\\u2002\",\n  emsp: \"\\u2003\",\n  thinsp: \"\\u2009\",\n  zwnj: \"\\u200C\",\n  zwj: \"\\u200D\",\n  lrm: \"\\u200E\",\n  rlm: \"\\u200F\",\n  ndash: \"\\u2013\",\n  mdash: \"\\u2014\",\n  lsquo: \"\\u2018\",\n  rsquo: \"\\u2019\",\n  sbquo: \"\\u201A\",\n  ldquo: \"\\u201C\",\n  rdquo: \"\\u201D\",\n  bdquo: \"\\u201E\",\n  dagger: \"\\u2020\",\n  Dagger: \"\\u2021\",\n  bull: \"\\u2022\",\n  hellip: \"\\u2026\",\n  permil: \"\\u2030\",\n  prime: \"\\u2032\",\n  Prime: \"\\u2033\",\n  lsaquo: \"\\u2039\",\n  rsaquo: \"\\u203A\",\n  oline: \"\\u203E\",\n  frasl: \"\\u2044\",\n  euro: \"\\u20AC\",\n  image: \"\\u2111\",\n  weierp: \"\\u2118\",\n  real: \"\\u211C\",\n  trade: \"\\u2122\",\n  alefsym: \"\\u2135\",\n  larr: \"\\u2190\",\n  uarr: \"\\u2191\",\n  rarr: \"\\u2192\",\n  darr: \"\\u2193\",\n  harr: \"\\u2194\",\n  crarr: \"\\u21B5\",\n  lArr: \"\\u21D0\",\n  uArr: \"\\u21D1\",\n  rArr: \"\\u21D2\",\n  dArr: \"\\u21D3\",\n  hArr: \"\\u21D4\",\n  forall: \"\\u2200\",\n  part: \"\\u2202\",\n  exist: \"\\u2203\",\n  empty: \"\\u2205\",\n  nabla: \"\\u2207\",\n  isin: \"\\u2208\",\n  notin: \"\\u2209\",\n  ni: \"\\u220B\",\n  prod: \"\\u220F\",\n  sum: \"\\u2211\",\n  minus: \"\\u2212\",\n  lowast: \"\\u2217\",\n  radic: \"\\u221A\",\n  prop: \"\\u221D\",\n  infin: \"\\u221E\",\n  ang: \"\\u2220\",\n  and: \"\\u2227\",\n  or: \"\\u2228\",\n  cap: \"\\u2229\",\n  cup: \"\\u222A\",\n  int: \"\\u222B\",\n  there4: \"\\u2234\",\n  sim: \"\\u223C\",\n  cong: \"\\u2245\",\n  asymp: \"\\u2248\",\n  ne: \"\\u2260\",\n  equiv: \"\\u2261\",\n  le: \"\\u2264\",\n  ge: \"\\u2265\",\n  sub: \"\\u2282\",\n  sup: \"\\u2283\",\n  nsub: \"\\u2284\",\n  sube: \"\\u2286\",\n  supe: \"\\u2287\",\n  oplus: \"\\u2295\",\n  otimes: \"\\u2297\",\n  perp: \"\\u22A5\",\n  sdot: \"\\u22C5\",\n  lceil: \"\\u2308\",\n  rceil: \"\\u2309\",\n  lfloor: \"\\u230A\",\n  rfloor: \"\\u230B\",\n  lang: \"\\u2329\",\n  rang: \"\\u232A\",\n  loz: \"\\u25CA\",\n  spades: \"\\u2660\",\n  clubs: \"\\u2663\",\n  hearts: \"\\u2665\",\n  diams: \"\\u2666\"\n};\nvar HEX_NUMBER = /^[\\da-fA-F]+$/;\nvar DECIMAL_NUMBER = /^\\d+$/;\nvar JsxErrors = Object.freeze({\n  AttributeIsEmpty: \"JSX attributes must only be assigned a non-empty expression\",\n  MissingClosingTagFragment: \"Expected corresponding JSX closing tag for <>\",\n  MissingClosingTagElement: \"Expected corresponding JSX closing tag for <%0>\",\n  UnsupportedJsxValue: \"JSX value should be either an expression or a quoted JSX text\",\n  UnterminatedJsxContent: \"Unterminated JSX contents\",\n  UnwrappedAdjacentJSXElements: \"Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?\"\n});\ntypes$1.j_oTag = new TokContext(\"<tag\", false);\ntypes$1.j_cTag = new TokContext(\"</tag\", false);\ntypes$1.j_expr = new TokContext(\"<tag>...</tag>\", true, true);\ntypes.jsxName = new TokenType(\"jsxName\");\ntypes.jsxText = new TokenType(\"jsxText\", {\n  beforeExpr: true\n});\ntypes.jsxTagStart = new TokenType(\"jsxTagStart\", {\n  startsExpr: true\n});\ntypes.jsxTagEnd = new TokenType(\"jsxTagEnd\");\n\ntypes.jsxTagStart.updateContext = function () {\n  this.state.context.push(types$1.j_expr);\n  this.state.context.push(types$1.j_oTag);\n  this.state.exprAllowed = false;\n};\n\ntypes.jsxTagEnd.updateContext = function (prevType) {\n  var out = this.state.context.pop();\n\n  if (out === types$1.j_oTag && prevType === types.slash || out === types$1.j_cTag) {\n    this.state.context.pop();\n    this.state.exprAllowed = this.curContext() === types$1.j_expr;\n  } else {\n    this.state.exprAllowed = true;\n  }\n};\n\nfunction isFragment(object) {\n  return object ? object.type === \"JSXOpeningFragment\" || object.type === \"JSXClosingFragment\" : false;\n}\n\nfunction getQualifiedJSXName(object) {\n  if (object.type === \"JSXIdentifier\") {\n    return object.name;\n  }\n\n  if (object.type === \"JSXNamespacedName\") {\n    return object.namespace.name + \":\" + object.name.name;\n  }\n\n  if (object.type === \"JSXMemberExpression\") {\n    return getQualifiedJSXName(object.object) + \".\" + getQualifiedJSXName(object.property);\n  }\n\n  throw new Error(\"Node had unexpected type: \" + object.type);\n}\n\nvar jsx = function jsx(superClass) {\n  return /*#__PURE__*/function (_superClass3) {\n    _inherits(_class3, _superClass3);\n\n    var _super5 = _createSuper(_class3);\n\n    function _class3() {\n      _classCallCheck(this, _class3);\n\n      return _super5.apply(this, arguments);\n    }\n\n    _createClass(_class3, [{\n      key: \"jsxReadToken\",\n      value: function jsxReadToken() {\n        var out = \"\";\n        var chunkStart = this.state.pos;\n\n        for (;;) {\n          if (this.state.pos >= this.length) {\n            throw this.raise(this.state.start, JsxErrors.UnterminatedJsxContent);\n          }\n\n          var ch = this.input.charCodeAt(this.state.pos);\n\n          switch (ch) {\n            case 60:\n            case 123:\n              if (this.state.pos === this.state.start) {\n                if (ch === 60 && this.state.exprAllowed) {\n                  ++this.state.pos;\n                  return this.finishToken(types.jsxTagStart);\n                }\n\n                return _get(_getPrototypeOf(_class3.prototype), \"getTokenFromCode\", this).call(this, ch);\n              }\n\n              out += this.input.slice(chunkStart, this.state.pos);\n              return this.finishToken(types.jsxText, out);\n\n            case 38:\n              out += this.input.slice(chunkStart, this.state.pos);\n              out += this.jsxReadEntity();\n              chunkStart = this.state.pos;\n              break;\n\n            default:\n              if (isNewLine(ch)) {\n                out += this.input.slice(chunkStart, this.state.pos);\n                out += this.jsxReadNewLine(true);\n                chunkStart = this.state.pos;\n              } else {\n                ++this.state.pos;\n              }\n\n          }\n        }\n      }\n    }, {\n      key: \"jsxReadNewLine\",\n      value: function jsxReadNewLine(normalizeCRLF) {\n        var ch = this.input.charCodeAt(this.state.pos);\n        var out;\n        ++this.state.pos;\n\n        if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {\n          ++this.state.pos;\n          out = normalizeCRLF ? \"\\n\" : \"\\r\\n\";\n        } else {\n          out = String.fromCharCode(ch);\n        }\n\n        ++this.state.curLine;\n        this.state.lineStart = this.state.pos;\n        return out;\n      }\n    }, {\n      key: \"jsxReadString\",\n      value: function jsxReadString(quote) {\n        var out = \"\";\n        var chunkStart = ++this.state.pos;\n\n        for (;;) {\n          if (this.state.pos >= this.length) {\n            throw this.raise(this.state.start, ErrorMessages.UnterminatedString);\n          }\n\n          var ch = this.input.charCodeAt(this.state.pos);\n          if (ch === quote) break;\n\n          if (ch === 38) {\n            out += this.input.slice(chunkStart, this.state.pos);\n            out += this.jsxReadEntity();\n            chunkStart = this.state.pos;\n          } else if (isNewLine(ch)) {\n            out += this.input.slice(chunkStart, this.state.pos);\n            out += this.jsxReadNewLine(false);\n            chunkStart = this.state.pos;\n          } else {\n            ++this.state.pos;\n          }\n        }\n\n        out += this.input.slice(chunkStart, this.state.pos++);\n        return this.finishToken(types.string, out);\n      }\n    }, {\n      key: \"jsxReadEntity\",\n      value: function jsxReadEntity() {\n        var str = \"\";\n        var count = 0;\n        var entity;\n        var ch = this.input[this.state.pos];\n        var startPos = ++this.state.pos;\n\n        while (this.state.pos < this.length && count++ < 10) {\n          ch = this.input[this.state.pos++];\n\n          if (ch === \";\") {\n            if (str[0] === \"#\") {\n              if (str[1] === \"x\") {\n                str = str.substr(2);\n\n                if (HEX_NUMBER.test(str)) {\n                  entity = String.fromCodePoint(parseInt(str, 16));\n                }\n              } else {\n                str = str.substr(1);\n\n                if (DECIMAL_NUMBER.test(str)) {\n                  entity = String.fromCodePoint(parseInt(str, 10));\n                }\n              }\n            } else {\n              entity = entities[str];\n            }\n\n            break;\n          }\n\n          str += ch;\n        }\n\n        if (!entity) {\n          this.state.pos = startPos;\n          return \"&\";\n        }\n\n        return entity;\n      }\n    }, {\n      key: \"jsxReadWord\",\n      value: function jsxReadWord() {\n        var ch;\n        var start = this.state.pos;\n\n        do {\n          ch = this.input.charCodeAt(++this.state.pos);\n        } while (isIdentifierChar(ch) || ch === 45);\n\n        return this.finishToken(types.jsxName, this.input.slice(start, this.state.pos));\n      }\n    }, {\n      key: \"jsxParseIdentifier\",\n      value: function jsxParseIdentifier() {\n        var node = this.startNode();\n\n        if (this.match(types.jsxName)) {\n          node.name = this.state.value;\n        } else if (this.state.type.keyword) {\n          node.name = this.state.type.keyword;\n        } else {\n          this.unexpected();\n        }\n\n        this.next();\n        return this.finishNode(node, \"JSXIdentifier\");\n      }\n    }, {\n      key: \"jsxParseNamespacedName\",\n      value: function jsxParseNamespacedName() {\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        var name = this.jsxParseIdentifier();\n        if (!this.eat(types.colon)) return name;\n        var node = this.startNodeAt(startPos, startLoc);\n        node.namespace = name;\n        node.name = this.jsxParseIdentifier();\n        return this.finishNode(node, \"JSXNamespacedName\");\n      }\n    }, {\n      key: \"jsxParseElementName\",\n      value: function jsxParseElementName() {\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        var node = this.jsxParseNamespacedName();\n\n        if (node.type === \"JSXNamespacedName\") {\n          return node;\n        }\n\n        while (this.eat(types.dot)) {\n          var newNode = this.startNodeAt(startPos, startLoc);\n          newNode.object = node;\n          newNode.property = this.jsxParseIdentifier();\n          node = this.finishNode(newNode, \"JSXMemberExpression\");\n        }\n\n        return node;\n      }\n    }, {\n      key: \"jsxParseAttributeValue\",\n      value: function jsxParseAttributeValue() {\n        var node;\n\n        switch (this.state.type) {\n          case types.braceL:\n            node = this.startNode();\n            this.next();\n            node = this.jsxParseExpressionContainer(node);\n\n            if (node.expression.type === \"JSXEmptyExpression\") {\n              this.raise(node.start, JsxErrors.AttributeIsEmpty);\n            }\n\n            return node;\n\n          case types.jsxTagStart:\n          case types.string:\n            return this.parseExprAtom();\n\n          default:\n            throw this.raise(this.state.start, JsxErrors.UnsupportedJsxValue);\n        }\n      }\n    }, {\n      key: \"jsxParseEmptyExpression\",\n      value: function jsxParseEmptyExpression() {\n        var node = this.startNodeAt(this.state.lastTokEnd, this.state.lastTokEndLoc);\n        return this.finishNodeAt(node, \"JSXEmptyExpression\", this.state.start, this.state.startLoc);\n      }\n    }, {\n      key: \"jsxParseSpreadChild\",\n      value: function jsxParseSpreadChild(node) {\n        this.next();\n        node.expression = this.parseExpression();\n        this.expect(types.braceR);\n        return this.finishNode(node, \"JSXSpreadChild\");\n      }\n    }, {\n      key: \"jsxParseExpressionContainer\",\n      value: function jsxParseExpressionContainer(node) {\n        if (this.match(types.braceR)) {\n          node.expression = this.jsxParseEmptyExpression();\n        } else {\n          node.expression = this.parseExpression();\n        }\n\n        this.expect(types.braceR);\n        return this.finishNode(node, \"JSXExpressionContainer\");\n      }\n    }, {\n      key: \"jsxParseAttribute\",\n      value: function jsxParseAttribute() {\n        var node = this.startNode();\n\n        if (this.eat(types.braceL)) {\n          this.expect(types.ellipsis);\n          node.argument = this.parseMaybeAssignAllowIn();\n          this.expect(types.braceR);\n          return this.finishNode(node, \"JSXSpreadAttribute\");\n        }\n\n        node.name = this.jsxParseNamespacedName();\n        node.value = this.eat(types.eq) ? this.jsxParseAttributeValue() : null;\n        return this.finishNode(node, \"JSXAttribute\");\n      }\n    }, {\n      key: \"jsxParseOpeningElementAt\",\n      value: function jsxParseOpeningElementAt(startPos, startLoc) {\n        var node = this.startNodeAt(startPos, startLoc);\n\n        if (this.match(types.jsxTagEnd)) {\n          this.expect(types.jsxTagEnd);\n          return this.finishNode(node, \"JSXOpeningFragment\");\n        }\n\n        node.name = this.jsxParseElementName();\n        return this.jsxParseOpeningElementAfterName(node);\n      }\n    }, {\n      key: \"jsxParseOpeningElementAfterName\",\n      value: function jsxParseOpeningElementAfterName(node) {\n        var attributes = [];\n\n        while (!this.match(types.slash) && !this.match(types.jsxTagEnd)) {\n          attributes.push(this.jsxParseAttribute());\n        }\n\n        node.attributes = attributes;\n        node.selfClosing = this.eat(types.slash);\n        this.expect(types.jsxTagEnd);\n        return this.finishNode(node, \"JSXOpeningElement\");\n      }\n    }, {\n      key: \"jsxParseClosingElementAt\",\n      value: function jsxParseClosingElementAt(startPos, startLoc) {\n        var node = this.startNodeAt(startPos, startLoc);\n\n        if (this.match(types.jsxTagEnd)) {\n          this.expect(types.jsxTagEnd);\n          return this.finishNode(node, \"JSXClosingFragment\");\n        }\n\n        node.name = this.jsxParseElementName();\n        this.expect(types.jsxTagEnd);\n        return this.finishNode(node, \"JSXClosingElement\");\n      }\n    }, {\n      key: \"jsxParseElementAt\",\n      value: function jsxParseElementAt(startPos, startLoc) {\n        var node = this.startNodeAt(startPos, startLoc);\n        var children = [];\n        var openingElement = this.jsxParseOpeningElementAt(startPos, startLoc);\n        var closingElement = null;\n\n        if (!openingElement.selfClosing) {\n          contents: for (;;) {\n            switch (this.state.type) {\n              case types.jsxTagStart:\n                startPos = this.state.start;\n                startLoc = this.state.startLoc;\n                this.next();\n\n                if (this.eat(types.slash)) {\n                  closingElement = this.jsxParseClosingElementAt(startPos, startLoc);\n                  break contents;\n                }\n\n                children.push(this.jsxParseElementAt(startPos, startLoc));\n                break;\n\n              case types.jsxText:\n                children.push(this.parseExprAtom());\n                break;\n\n              case types.braceL:\n                {\n                  var _node5 = this.startNode();\n\n                  this.next();\n\n                  if (this.match(types.ellipsis)) {\n                    children.push(this.jsxParseSpreadChild(_node5));\n                  } else {\n                    children.push(this.jsxParseExpressionContainer(_node5));\n                  }\n\n                  break;\n                }\n\n              default:\n                throw this.unexpected();\n            }\n          }\n\n          if (isFragment(openingElement) && !isFragment(closingElement)) {\n            this.raise(closingElement.start, JsxErrors.MissingClosingTagFragment);\n          } else if (!isFragment(openingElement) && isFragment(closingElement)) {\n            this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));\n          } else if (!isFragment(openingElement) && !isFragment(closingElement)) {\n            if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {\n              this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));\n            }\n          }\n        }\n\n        if (isFragment(openingElement)) {\n          node.openingFragment = openingElement;\n          node.closingFragment = closingElement;\n        } else {\n          node.openingElement = openingElement;\n          node.closingElement = closingElement;\n        }\n\n        node.children = children;\n\n        if (this.isRelational(\"<\")) {\n          throw this.raise(this.state.start, JsxErrors.UnwrappedAdjacentJSXElements);\n        }\n\n        return isFragment(openingElement) ? this.finishNode(node, \"JSXFragment\") : this.finishNode(node, \"JSXElement\");\n      }\n    }, {\n      key: \"jsxParseElement\",\n      value: function jsxParseElement() {\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        this.next();\n        return this.jsxParseElementAt(startPos, startLoc);\n      }\n    }, {\n      key: \"parseExprAtom\",\n      value: function parseExprAtom(refExpressionErrors) {\n        if (this.match(types.jsxText)) {\n          return this.parseLiteral(this.state.value, \"JSXText\");\n        } else if (this.match(types.jsxTagStart)) {\n          return this.jsxParseElement();\n        } else if (this.isRelational(\"<\") && this.input.charCodeAt(this.state.pos) !== 33) {\n          this.finishToken(types.jsxTagStart);\n          return this.jsxParseElement();\n        } else {\n          return _get(_getPrototypeOf(_class3.prototype), \"parseExprAtom\", this).call(this, refExpressionErrors);\n        }\n      }\n    }, {\n      key: \"getTokenFromCode\",\n      value: function getTokenFromCode(code) {\n        if (this.state.inPropertyName) return _get(_getPrototypeOf(_class3.prototype), \"getTokenFromCode\", this).call(this, code);\n        var context = this.curContext();\n\n        if (context === types$1.j_expr) {\n          return this.jsxReadToken();\n        }\n\n        if (context === types$1.j_oTag || context === types$1.j_cTag) {\n          if (isIdentifierStart(code)) {\n            return this.jsxReadWord();\n          }\n\n          if (code === 62) {\n            ++this.state.pos;\n            return this.finishToken(types.jsxTagEnd);\n          }\n\n          if ((code === 34 || code === 39) && context === types$1.j_oTag) {\n            return this.jsxReadString(code);\n          }\n        }\n\n        if (code === 60 && this.state.exprAllowed && this.input.charCodeAt(this.state.pos + 1) !== 33) {\n          ++this.state.pos;\n          return this.finishToken(types.jsxTagStart);\n        }\n\n        return _get(_getPrototypeOf(_class3.prototype), \"getTokenFromCode\", this).call(this, code);\n      }\n    }, {\n      key: \"updateContext\",\n      value: function updateContext(prevType) {\n        if (this.match(types.braceL)) {\n          var curContext = this.curContext();\n\n          if (curContext === types$1.j_oTag) {\n            this.state.context.push(types$1.braceExpression);\n          } else if (curContext === types$1.j_expr) {\n            this.state.context.push(types$1.templateQuasi);\n          } else {\n            _get(_getPrototypeOf(_class3.prototype), \"updateContext\", this).call(this, prevType);\n          }\n\n          this.state.exprAllowed = true;\n        } else if (this.match(types.slash) && prevType === types.jsxTagStart) {\n          this.state.context.length -= 2;\n          this.state.context.push(types$1.j_cTag);\n          this.state.exprAllowed = false;\n        } else {\n          return _get(_getPrototypeOf(_class3.prototype), \"updateContext\", this).call(this, prevType);\n        }\n      }\n    }]);\n\n    return _class3;\n  }(superClass);\n};\n\nvar Scope = function Scope(flags) {\n  _classCallCheck(this, Scope);\n\n  this.var = [];\n  this.lexical = [];\n  this.functions = [];\n  this.flags = flags;\n};\n\nvar ScopeHandler = /*#__PURE__*/function () {\n  function ScopeHandler(raise, inModule) {\n    _classCallCheck(this, ScopeHandler);\n\n    this.scopeStack = [];\n    this.undefinedExports = new Map();\n    this.undefinedPrivateNames = new Map();\n    this.raise = raise;\n    this.inModule = inModule;\n  }\n\n  _createClass(ScopeHandler, [{\n    key: \"createScope\",\n    value: function createScope(flags) {\n      return new Scope(flags);\n    }\n  }, {\n    key: \"enter\",\n    value: function enter(flags) {\n      this.scopeStack.push(this.createScope(flags));\n    }\n  }, {\n    key: \"exit\",\n    value: function exit() {\n      this.scopeStack.pop();\n    }\n  }, {\n    key: \"treatFunctionsAsVarInScope\",\n    value: function treatFunctionsAsVarInScope(scope) {\n      return !!(scope.flags & SCOPE_FUNCTION || !this.inModule && scope.flags & SCOPE_PROGRAM);\n    }\n  }, {\n    key: \"declareName\",\n    value: function declareName(name, bindingType, pos) {\n      var scope = this.currentScope();\n\n      if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {\n        this.checkRedeclarationInScope(scope, name, bindingType, pos);\n\n        if (bindingType & BIND_SCOPE_FUNCTION) {\n          scope.functions.push(name);\n        } else {\n          scope.lexical.push(name);\n        }\n\n        if (bindingType & BIND_SCOPE_LEXICAL) {\n          this.maybeExportDefined(scope, name);\n        }\n      } else if (bindingType & BIND_SCOPE_VAR) {\n        for (var i = this.scopeStack.length - 1; i >= 0; --i) {\n          scope = this.scopeStack[i];\n          this.checkRedeclarationInScope(scope, name, bindingType, pos);\n          scope.var.push(name);\n          this.maybeExportDefined(scope, name);\n          if (scope.flags & SCOPE_VAR) break;\n        }\n      }\n\n      if (this.inModule && scope.flags & SCOPE_PROGRAM) {\n        this.undefinedExports.delete(name);\n      }\n    }\n  }, {\n    key: \"maybeExportDefined\",\n    value: function maybeExportDefined(scope, name) {\n      if (this.inModule && scope.flags & SCOPE_PROGRAM) {\n        this.undefinedExports.delete(name);\n      }\n    }\n  }, {\n    key: \"checkRedeclarationInScope\",\n    value: function checkRedeclarationInScope(scope, name, bindingType, pos) {\n      if (this.isRedeclaredInScope(scope, name, bindingType)) {\n        this.raise(pos, ErrorMessages.VarRedeclaration, name);\n      }\n    }\n  }, {\n    key: \"isRedeclaredInScope\",\n    value: function isRedeclaredInScope(scope, name, bindingType) {\n      if (!(bindingType & BIND_KIND_VALUE)) return false;\n\n      if (bindingType & BIND_SCOPE_LEXICAL) {\n        return scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;\n      }\n\n      if (bindingType & BIND_SCOPE_FUNCTION) {\n        return scope.lexical.indexOf(name) > -1 || !this.treatFunctionsAsVarInScope(scope) && scope.var.indexOf(name) > -1;\n      }\n\n      return scope.lexical.indexOf(name) > -1 && !(scope.flags & SCOPE_SIMPLE_CATCH && scope.lexical[0] === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.indexOf(name) > -1;\n    }\n  }, {\n    key: \"checkLocalExport\",\n    value: function checkLocalExport(id) {\n      if (this.scopeStack[0].lexical.indexOf(id.name) === -1 && this.scopeStack[0].var.indexOf(id.name) === -1 && this.scopeStack[0].functions.indexOf(id.name) === -1) {\n        this.undefinedExports.set(id.name, id.start);\n      }\n    }\n  }, {\n    key: \"currentScope\",\n    value: function currentScope() {\n      return this.scopeStack[this.scopeStack.length - 1];\n    }\n  }, {\n    key: \"currentVarScope\",\n    value: function currentVarScope() {\n      for (var i = this.scopeStack.length - 1;; i--) {\n        var scope = this.scopeStack[i];\n\n        if (scope.flags & SCOPE_VAR) {\n          return scope;\n        }\n      }\n    }\n  }, {\n    key: \"currentThisScope\",\n    value: function currentThisScope() {\n      for (var i = this.scopeStack.length - 1;; i--) {\n        var scope = this.scopeStack[i];\n\n        if ((scope.flags & SCOPE_VAR || scope.flags & SCOPE_CLASS) && !(scope.flags & SCOPE_ARROW)) {\n          return scope;\n        }\n      }\n    }\n  }, {\n    key: \"inFunction\",\n    get: function get() {\n      return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0;\n    }\n  }, {\n    key: \"allowSuper\",\n    get: function get() {\n      return (this.currentThisScope().flags & SCOPE_SUPER) > 0;\n    }\n  }, {\n    key: \"allowDirectSuper\",\n    get: function get() {\n      return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0;\n    }\n  }, {\n    key: \"inClass\",\n    get: function get() {\n      return (this.currentThisScope().flags & SCOPE_CLASS) > 0;\n    }\n  }, {\n    key: \"inNonArrowFunction\",\n    get: function get() {\n      return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0;\n    }\n  }, {\n    key: \"treatFunctionsAsVar\",\n    get: function get() {\n      return this.treatFunctionsAsVarInScope(this.currentScope());\n    }\n  }]);\n\n  return ScopeHandler;\n}();\n\nvar TypeScriptScope = /*#__PURE__*/function (_Scope) {\n  _inherits(TypeScriptScope, _Scope);\n\n  var _super6 = _createSuper(TypeScriptScope);\n\n  function TypeScriptScope() {\n    var _this16;\n\n    _classCallCheck(this, TypeScriptScope);\n\n    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      args[_key3] = arguments[_key3];\n    }\n\n    _this16 = _super6.call.apply(_super6, [this].concat(args));\n    _this16.types = [];\n    _this16.enums = [];\n    _this16.constEnums = [];\n    _this16.classes = [];\n    _this16.exportOnlyBindings = [];\n    return _this16;\n  }\n\n  return TypeScriptScope;\n}(Scope);\n\nvar TypeScriptScopeHandler = /*#__PURE__*/function (_ScopeHandler) {\n  _inherits(TypeScriptScopeHandler, _ScopeHandler);\n\n  var _super7 = _createSuper(TypeScriptScopeHandler);\n\n  function TypeScriptScopeHandler() {\n    _classCallCheck(this, TypeScriptScopeHandler);\n\n    return _super7.apply(this, arguments);\n  }\n\n  _createClass(TypeScriptScopeHandler, [{\n    key: \"createScope\",\n    value: function createScope(flags) {\n      return new TypeScriptScope(flags);\n    }\n  }, {\n    key: \"declareName\",\n    value: function declareName(name, bindingType, pos) {\n      var scope = this.currentScope();\n\n      if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {\n        this.maybeExportDefined(scope, name);\n        scope.exportOnlyBindings.push(name);\n        return;\n      }\n\n      _get(_getPrototypeOf(TypeScriptScopeHandler.prototype), \"declareName\", this).apply(this, arguments);\n\n      if (bindingType & BIND_KIND_TYPE) {\n        if (!(bindingType & BIND_KIND_VALUE)) {\n          this.checkRedeclarationInScope(scope, name, bindingType, pos);\n          this.maybeExportDefined(scope, name);\n        }\n\n        scope.types.push(name);\n      }\n\n      if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.push(name);\n      if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.push(name);\n      if (bindingType & BIND_FLAGS_CLASS) scope.classes.push(name);\n    }\n  }, {\n    key: \"isRedeclaredInScope\",\n    value: function isRedeclaredInScope(scope, name, bindingType) {\n      if (scope.enums.indexOf(name) > -1) {\n        if (bindingType & BIND_FLAGS_TS_ENUM) {\n          var isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM);\n          var wasConst = scope.constEnums.indexOf(name) > -1;\n          return isConst !== wasConst;\n        }\n\n        return true;\n      }\n\n      if (bindingType & BIND_FLAGS_CLASS && scope.classes.indexOf(name) > -1) {\n        if (scope.lexical.indexOf(name) > -1) {\n          return !!(bindingType & BIND_KIND_VALUE);\n        } else {\n          return false;\n        }\n      }\n\n      if (bindingType & BIND_KIND_TYPE && scope.types.indexOf(name) > -1) {\n        return true;\n      }\n\n      return _get(_getPrototypeOf(TypeScriptScopeHandler.prototype), \"isRedeclaredInScope\", this).apply(this, arguments);\n    }\n  }, {\n    key: \"checkLocalExport\",\n    value: function checkLocalExport(id) {\n      if (this.scopeStack[0].types.indexOf(id.name) === -1 && this.scopeStack[0].exportOnlyBindings.indexOf(id.name) === -1) {\n        _get(_getPrototypeOf(TypeScriptScopeHandler.prototype), \"checkLocalExport\", this).call(this, id);\n      }\n    }\n  }]);\n\n  return TypeScriptScopeHandler;\n}(ScopeHandler);\n\nvar PARAM = 0,\n    PARAM_YIELD = 1,\n    PARAM_AWAIT = 2,\n    PARAM_RETURN = 4,\n    PARAM_IN = 8;\n\nvar ProductionParameterHandler = /*#__PURE__*/function () {\n  function ProductionParameterHandler() {\n    _classCallCheck(this, ProductionParameterHandler);\n\n    this.stacks = [];\n  }\n\n  _createClass(ProductionParameterHandler, [{\n    key: \"enter\",\n    value: function enter(flags) {\n      this.stacks.push(flags);\n    }\n  }, {\n    key: \"exit\",\n    value: function exit() {\n      this.stacks.pop();\n    }\n  }, {\n    key: \"currentFlags\",\n    value: function currentFlags() {\n      return this.stacks[this.stacks.length - 1];\n    }\n  }, {\n    key: \"hasAwait\",\n    get: function get() {\n      return (this.currentFlags() & PARAM_AWAIT) > 0;\n    }\n  }, {\n    key: \"hasYield\",\n    get: function get() {\n      return (this.currentFlags() & PARAM_YIELD) > 0;\n    }\n  }, {\n    key: \"hasReturn\",\n    get: function get() {\n      return (this.currentFlags() & PARAM_RETURN) > 0;\n    }\n  }, {\n    key: \"hasIn\",\n    get: function get() {\n      return (this.currentFlags() & PARAM_IN) > 0;\n    }\n  }]);\n\n  return ProductionParameterHandler;\n}();\n\nfunction functionFlags(isAsync, isGenerator) {\n  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);\n}\n\nfunction nonNull(x) {\n  if (x == null) {\n    throw new Error(\"Unexpected \".concat(x, \" value.\"));\n  }\n\n  return x;\n}\n\nfunction assert(x) {\n  if (!x) {\n    throw new Error(\"Assert fail\");\n  }\n}\n\nvar TSErrors = Object.freeze({\n  ClassMethodHasDeclare: \"Class methods cannot have the 'declare' modifier\",\n  ClassMethodHasReadonly: \"Class methods cannot have the 'readonly' modifier\",\n  DeclareClassFieldHasInitializer: \"'declare' class fields cannot have an initializer\",\n  DuplicateModifier: \"Duplicate modifier: '%0'\",\n  EmptyHeritageClauseType: \"'%0' list cannot be empty.\",\n  IndexSignatureHasAbstract: \"Index signatures cannot have the 'abstract' modifier\",\n  IndexSignatureHasAccessibility: \"Index signatures cannot have an accessibility modifier ('%0')\",\n  IndexSignatureHasStatic: \"Index signatures cannot have the 'static' modifier\",\n  InvalidTupleMemberLabel: \"Tuple members must be labeled with a simple identifier.\",\n  MixedLabeledAndUnlabeledElements: \"Tuple members must all have names or all not have names.\",\n  OptionalTypeBeforeRequired: \"A required element cannot follow an optional element.\",\n  PatternIsOptional: \"A binding pattern parameter cannot be optional in an implementation signature.\",\n  PrivateElementHasAbstract: \"Private elements cannot have the 'abstract' modifier.\",\n  PrivateElementHasAccessibility: \"Private elements cannot have an accessibility modifier ('%0')\",\n  TemplateTypeHasSubstitution: \"Template literal types cannot have any substitution\",\n  TypeAnnotationAfterAssign: \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`\",\n  UnexpectedReadonly: \"'readonly' type modifier is only permitted on array and tuple literal types.\",\n  UnexpectedTypeAnnotation: \"Did not expect a type annotation here.\",\n  UnexpectedTypeCastInParameter: \"Unexpected type cast in parameter position.\",\n  UnsupportedImportTypeArgument: \"Argument in a type import must be a string literal\",\n  UnsupportedParameterPropertyKind: \"A parameter property may not be declared using a binding pattern.\",\n  UnsupportedSignatureParameterKind: \"Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got %0\"\n});\n\nfunction keywordTypeFromName(value) {\n  switch (value) {\n    case \"any\":\n      return \"TSAnyKeyword\";\n\n    case \"boolean\":\n      return \"TSBooleanKeyword\";\n\n    case \"bigint\":\n      return \"TSBigIntKeyword\";\n\n    case \"never\":\n      return \"TSNeverKeyword\";\n\n    case \"number\":\n      return \"TSNumberKeyword\";\n\n    case \"object\":\n      return \"TSObjectKeyword\";\n\n    case \"string\":\n      return \"TSStringKeyword\";\n\n    case \"symbol\":\n      return \"TSSymbolKeyword\";\n\n    case \"undefined\":\n      return \"TSUndefinedKeyword\";\n\n    case \"unknown\":\n      return \"TSUnknownKeyword\";\n\n    default:\n      return undefined;\n  }\n}\n\nvar typescript = function typescript(superClass) {\n  return /*#__PURE__*/function (_superClass4) {\n    _inherits(_class4, _superClass4);\n\n    var _super8 = _createSuper(_class4);\n\n    function _class4() {\n      _classCallCheck(this, _class4);\n\n      return _super8.apply(this, arguments);\n    }\n\n    _createClass(_class4, [{\n      key: \"getScopeHandler\",\n      value: function getScopeHandler() {\n        return TypeScriptScopeHandler;\n      }\n    }, {\n      key: \"tsIsIdentifier\",\n      value: function tsIsIdentifier() {\n        return this.match(types.name);\n      }\n    }, {\n      key: \"tsNextTokenCanFollowModifier\",\n      value: function tsNextTokenCanFollowModifier() {\n        this.next();\n        return !this.hasPrecedingLineBreak() && !this.match(types.parenL) && !this.match(types.parenR) && !this.match(types.colon) && !this.match(types.eq) && !this.match(types.question) && !this.match(types.bang);\n      }\n    }, {\n      key: \"tsParseModifier\",\n      value: function tsParseModifier(allowedModifiers) {\n        if (!this.match(types.name)) {\n          return undefined;\n        }\n\n        var modifier = this.state.value;\n\n        if (allowedModifiers.indexOf(modifier) !== -1 && this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {\n          return modifier;\n        }\n\n        return undefined;\n      }\n    }, {\n      key: \"tsParseModifiers\",\n      value: function tsParseModifiers(modified, allowedModifiers) {\n        for (;;) {\n          var startPos = this.state.start;\n          var modifier = this.tsParseModifier(allowedModifiers);\n          if (!modifier) break;\n\n          if (Object.hasOwnProperty.call(modified, modifier)) {\n            this.raise(startPos, TSErrors.DuplicateModifier, modifier);\n          }\n\n          modified[modifier] = true;\n        }\n      }\n    }, {\n      key: \"tsIsListTerminator\",\n      value: function tsIsListTerminator(kind) {\n        switch (kind) {\n          case \"EnumMembers\":\n          case \"TypeMembers\":\n            return this.match(types.braceR);\n\n          case \"HeritageClauseElement\":\n            return this.match(types.braceL);\n\n          case \"TupleElementTypes\":\n            return this.match(types.bracketR);\n\n          case \"TypeParametersOrArguments\":\n            return this.isRelational(\">\");\n        }\n\n        throw new Error(\"Unreachable\");\n      }\n    }, {\n      key: \"tsParseList\",\n      value: function tsParseList(kind, parseElement) {\n        var result = [];\n\n        while (!this.tsIsListTerminator(kind)) {\n          result.push(parseElement());\n        }\n\n        return result;\n      }\n    }, {\n      key: \"tsParseDelimitedList\",\n      value: function tsParseDelimitedList(kind, parseElement) {\n        return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true));\n      }\n    }, {\n      key: \"tsParseDelimitedListWorker\",\n      value: function tsParseDelimitedListWorker(kind, parseElement, expectSuccess) {\n        var result = [];\n\n        for (;;) {\n          if (this.tsIsListTerminator(kind)) {\n            break;\n          }\n\n          var element = parseElement();\n\n          if (element == null) {\n            return undefined;\n          }\n\n          result.push(element);\n\n          if (this.eat(types.comma)) {\n            continue;\n          }\n\n          if (this.tsIsListTerminator(kind)) {\n            break;\n          }\n\n          if (expectSuccess) {\n            this.expect(types.comma);\n          }\n\n          return undefined;\n        }\n\n        return result;\n      }\n    }, {\n      key: \"tsParseBracketedList\",\n      value: function tsParseBracketedList(kind, parseElement, bracket, skipFirstToken) {\n        if (!skipFirstToken) {\n          if (bracket) {\n            this.expect(types.bracketL);\n          } else {\n            this.expectRelational(\"<\");\n          }\n        }\n\n        var result = this.tsParseDelimitedList(kind, parseElement);\n\n        if (bracket) {\n          this.expect(types.bracketR);\n        } else {\n          this.expectRelational(\">\");\n        }\n\n        return result;\n      }\n    }, {\n      key: \"tsParseImportType\",\n      value: function tsParseImportType() {\n        var node = this.startNode();\n        this.expect(types._import);\n        this.expect(types.parenL);\n\n        if (!this.match(types.string)) {\n          this.raise(this.state.start, TSErrors.UnsupportedImportTypeArgument);\n        }\n\n        node.argument = this.parseExprAtom();\n        this.expect(types.parenR);\n\n        if (this.eat(types.dot)) {\n          node.qualifier = this.tsParseEntityName(true);\n        }\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.tsParseTypeArguments();\n        }\n\n        return this.finishNode(node, \"TSImportType\");\n      }\n    }, {\n      key: \"tsParseEntityName\",\n      value: function tsParseEntityName(allowReservedWords) {\n        var entity = this.parseIdentifier();\n\n        while (this.eat(types.dot)) {\n          var node = this.startNodeAtNode(entity);\n          node.left = entity;\n          node.right = this.parseIdentifier(allowReservedWords);\n          entity = this.finishNode(node, \"TSQualifiedName\");\n        }\n\n        return entity;\n      }\n    }, {\n      key: \"tsParseTypeReference\",\n      value: function tsParseTypeReference() {\n        var node = this.startNode();\n        node.typeName = this.tsParseEntityName(false);\n\n        if (!this.hasPrecedingLineBreak() && this.isRelational(\"<\")) {\n          node.typeParameters = this.tsParseTypeArguments();\n        }\n\n        return this.finishNode(node, \"TSTypeReference\");\n      }\n    }, {\n      key: \"tsParseThisTypePredicate\",\n      value: function tsParseThisTypePredicate(lhs) {\n        this.next();\n        var node = this.startNodeAtNode(lhs);\n        node.parameterName = lhs;\n        node.typeAnnotation = this.tsParseTypeAnnotation(false);\n        return this.finishNode(node, \"TSTypePredicate\");\n      }\n    }, {\n      key: \"tsParseThisTypeNode\",\n      value: function tsParseThisTypeNode() {\n        var node = this.startNode();\n        this.next();\n        return this.finishNode(node, \"TSThisType\");\n      }\n    }, {\n      key: \"tsParseTypeQuery\",\n      value: function tsParseTypeQuery() {\n        var node = this.startNode();\n        this.expect(types._typeof);\n\n        if (this.match(types._import)) {\n          node.exprName = this.tsParseImportType();\n        } else {\n          node.exprName = this.tsParseEntityName(true);\n        }\n\n        return this.finishNode(node, \"TSTypeQuery\");\n      }\n    }, {\n      key: \"tsParseTypeParameter\",\n      value: function tsParseTypeParameter() {\n        var node = this.startNode();\n        node.name = this.parseIdentifierName(node.start);\n        node.constraint = this.tsEatThenParseType(types._extends);\n        node.default = this.tsEatThenParseType(types.eq);\n        return this.finishNode(node, \"TSTypeParameter\");\n      }\n    }, {\n      key: \"tsTryParseTypeParameters\",\n      value: function tsTryParseTypeParameters() {\n        if (this.isRelational(\"<\")) {\n          return this.tsParseTypeParameters();\n        }\n      }\n    }, {\n      key: \"tsParseTypeParameters\",\n      value: function tsParseTypeParameters() {\n        var node = this.startNode();\n\n        if (this.isRelational(\"<\") || this.match(types.jsxTagStart)) {\n          this.next();\n        } else {\n          this.unexpected();\n        }\n\n        node.params = this.tsParseBracketedList(\"TypeParametersOrArguments\", this.tsParseTypeParameter.bind(this), false, true);\n        return this.finishNode(node, \"TSTypeParameterDeclaration\");\n      }\n    }, {\n      key: \"tsTryNextParseConstantContext\",\n      value: function tsTryNextParseConstantContext() {\n        if (this.lookahead().type === types._const) {\n          this.next();\n          return this.tsParseTypeReference();\n        }\n\n        return null;\n      }\n    }, {\n      key: \"tsFillSignature\",\n      value: function tsFillSignature(returnToken, signature) {\n        var returnTokenRequired = returnToken === types.arrow;\n        signature.typeParameters = this.tsTryParseTypeParameters();\n        this.expect(types.parenL);\n        signature.parameters = this.tsParseBindingListForSignature();\n\n        if (returnTokenRequired) {\n          signature.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n        } else if (this.match(returnToken)) {\n          signature.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n        }\n      }\n    }, {\n      key: \"tsParseBindingListForSignature\",\n      value: function tsParseBindingListForSignature() {\n        var _this17 = this;\n\n        return this.parseBindingList(types.parenR, 41).map(function (pattern) {\n          if (pattern.type !== \"Identifier\" && pattern.type !== \"RestElement\" && pattern.type !== \"ObjectPattern\" && pattern.type !== \"ArrayPattern\") {\n            _this17.raise(pattern.start, TSErrors.UnsupportedSignatureParameterKind, pattern.type);\n          }\n\n          return pattern;\n        });\n      }\n    }, {\n      key: \"tsParseTypeMemberSemicolon\",\n      value: function tsParseTypeMemberSemicolon() {\n        if (!this.eat(types.comma)) {\n          this.semicolon();\n        }\n      }\n    }, {\n      key: \"tsParseSignatureMember\",\n      value: function tsParseSignatureMember(kind, node) {\n        this.tsFillSignature(types.colon, node);\n        this.tsParseTypeMemberSemicolon();\n        return this.finishNode(node, kind);\n      }\n    }, {\n      key: \"tsIsUnambiguouslyIndexSignature\",\n      value: function tsIsUnambiguouslyIndexSignature() {\n        this.next();\n        return this.eat(types.name) && this.match(types.colon);\n      }\n    }, {\n      key: \"tsTryParseIndexSignature\",\n      value: function tsTryParseIndexSignature(node) {\n        if (!(this.match(types.bracketL) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {\n          return undefined;\n        }\n\n        this.expect(types.bracketL);\n        var id = this.parseIdentifier();\n        id.typeAnnotation = this.tsParseTypeAnnotation();\n        this.resetEndLocation(id);\n        this.expect(types.bracketR);\n        node.parameters = [id];\n        var type = this.tsTryParseTypeAnnotation();\n        if (type) node.typeAnnotation = type;\n        this.tsParseTypeMemberSemicolon();\n        return this.finishNode(node, \"TSIndexSignature\");\n      }\n    }, {\n      key: \"tsParsePropertyOrMethodSignature\",\n      value: function tsParsePropertyOrMethodSignature(node, readonly) {\n        if (this.eat(types.question)) node.optional = true;\n        var nodeAny = node;\n\n        if (!readonly && (this.match(types.parenL) || this.isRelational(\"<\"))) {\n          var method = nodeAny;\n          this.tsFillSignature(types.colon, method);\n          this.tsParseTypeMemberSemicolon();\n          return this.finishNode(method, \"TSMethodSignature\");\n        } else {\n          var property = nodeAny;\n          if (readonly) property.readonly = true;\n          var type = this.tsTryParseTypeAnnotation();\n          if (type) property.typeAnnotation = type;\n          this.tsParseTypeMemberSemicolon();\n          return this.finishNode(property, \"TSPropertySignature\");\n        }\n      }\n    }, {\n      key: \"tsParseTypeMember\",\n      value: function tsParseTypeMember() {\n        var node = this.startNode();\n\n        if (this.match(types.parenL) || this.isRelational(\"<\")) {\n          return this.tsParseSignatureMember(\"TSCallSignatureDeclaration\", node);\n        }\n\n        if (this.match(types._new)) {\n          var id = this.startNode();\n          this.next();\n\n          if (this.match(types.parenL) || this.isRelational(\"<\")) {\n            return this.tsParseSignatureMember(\"TSConstructSignatureDeclaration\", node);\n          } else {\n            node.key = this.createIdentifier(id, \"new\");\n            return this.tsParsePropertyOrMethodSignature(node, false);\n          }\n        }\n\n        var readonly = !!this.tsParseModifier([\"readonly\"]);\n        var idx = this.tsTryParseIndexSignature(node);\n\n        if (idx) {\n          if (readonly) node.readonly = true;\n          return idx;\n        }\n\n        this.parsePropertyName(node, false);\n        return this.tsParsePropertyOrMethodSignature(node, readonly);\n      }\n    }, {\n      key: \"tsParseTypeLiteral\",\n      value: function tsParseTypeLiteral() {\n        var node = this.startNode();\n        node.members = this.tsParseObjectTypeMembers();\n        return this.finishNode(node, \"TSTypeLiteral\");\n      }\n    }, {\n      key: \"tsParseObjectTypeMembers\",\n      value: function tsParseObjectTypeMembers() {\n        this.expect(types.braceL);\n        var members = this.tsParseList(\"TypeMembers\", this.tsParseTypeMember.bind(this));\n        this.expect(types.braceR);\n        return members;\n      }\n    }, {\n      key: \"tsIsStartOfMappedType\",\n      value: function tsIsStartOfMappedType() {\n        this.next();\n\n        if (this.eat(types.plusMin)) {\n          return this.isContextual(\"readonly\");\n        }\n\n        if (this.isContextual(\"readonly\")) {\n          this.next();\n        }\n\n        if (!this.match(types.bracketL)) {\n          return false;\n        }\n\n        this.next();\n\n        if (!this.tsIsIdentifier()) {\n          return false;\n        }\n\n        this.next();\n        return this.match(types._in);\n      }\n    }, {\n      key: \"tsParseMappedTypeParameter\",\n      value: function tsParseMappedTypeParameter() {\n        var node = this.startNode();\n        node.name = this.parseIdentifierName(node.start);\n        node.constraint = this.tsExpectThenParseType(types._in);\n        return this.finishNode(node, \"TSTypeParameter\");\n      }\n    }, {\n      key: \"tsParseMappedType\",\n      value: function tsParseMappedType() {\n        var node = this.startNode();\n        this.expect(types.braceL);\n\n        if (this.match(types.plusMin)) {\n          node.readonly = this.state.value;\n          this.next();\n          this.expectContextual(\"readonly\");\n        } else if (this.eatContextual(\"readonly\")) {\n          node.readonly = true;\n        }\n\n        this.expect(types.bracketL);\n        node.typeParameter = this.tsParseMappedTypeParameter();\n        this.expect(types.bracketR);\n\n        if (this.match(types.plusMin)) {\n          node.optional = this.state.value;\n          this.next();\n          this.expect(types.question);\n        } else if (this.eat(types.question)) {\n          node.optional = true;\n        }\n\n        node.typeAnnotation = this.tsTryParseType();\n        this.semicolon();\n        this.expect(types.braceR);\n        return this.finishNode(node, \"TSMappedType\");\n      }\n    }, {\n      key: \"tsParseTupleType\",\n      value: function tsParseTupleType() {\n        var _this18 = this;\n\n        var node = this.startNode();\n        node.elementTypes = this.tsParseBracketedList(\"TupleElementTypes\", this.tsParseTupleElementType.bind(this), true, false);\n        var seenOptionalElement = false;\n        var labeledElements = null;\n        node.elementTypes.forEach(function (elementNode) {\n          var _labeledElements;\n\n          var _elementNode = elementNode,\n              type = _elementNode.type;\n\n          if (seenOptionalElement && type !== \"TSRestType\" && type !== \"TSOptionalType\" && !(type === \"TSNamedTupleMember\" && elementNode.optional)) {\n            _this18.raise(elementNode.start, TSErrors.OptionalTypeBeforeRequired);\n          }\n\n          seenOptionalElement = seenOptionalElement || type === \"TSNamedTupleMember\" && elementNode.optional || type === \"TSOptionalType\";\n\n          if (type === \"TSRestType\") {\n            elementNode = elementNode.typeAnnotation;\n            type = elementNode.type;\n          }\n\n          var isLabeled = type === \"TSNamedTupleMember\";\n          labeledElements = (_labeledElements = labeledElements) != null ? _labeledElements : isLabeled;\n\n          if (labeledElements !== isLabeled) {\n            _this18.raise(elementNode.start, TSErrors.MixedLabeledAndUnlabeledElements);\n          }\n        });\n        return this.finishNode(node, \"TSTupleType\");\n      }\n    }, {\n      key: \"tsParseTupleElementType\",\n      value: function tsParseTupleElementType() {\n        var _this$state = this.state,\n            startPos = _this$state.start,\n            startLoc = _this$state.startLoc;\n        var rest = this.eat(types.ellipsis);\n        var type = this.tsParseType();\n        var optional = this.eat(types.question);\n        var labeled = this.eat(types.colon);\n\n        if (labeled) {\n          var labeledNode = this.startNodeAtNode(type);\n          labeledNode.optional = optional;\n\n          if (type.type === \"TSTypeReference\" && !type.typeParameters && type.typeName.type === \"Identifier\") {\n            labeledNode.label = type.typeName;\n          } else {\n            this.raise(type.start, TSErrors.InvalidTupleMemberLabel);\n            labeledNode.label = type;\n          }\n\n          labeledNode.elementType = this.tsParseType();\n          type = this.finishNode(labeledNode, \"TSNamedTupleMember\");\n        } else if (optional) {\n          var optionalTypeNode = this.startNodeAtNode(type);\n          optionalTypeNode.typeAnnotation = type;\n          type = this.finishNode(optionalTypeNode, \"TSOptionalType\");\n        }\n\n        if (rest) {\n          var restNode = this.startNodeAt(startPos, startLoc);\n          restNode.typeAnnotation = type;\n          type = this.finishNode(restNode, \"TSRestType\");\n        }\n\n        return type;\n      }\n    }, {\n      key: \"tsParseParenthesizedType\",\n      value: function tsParseParenthesizedType() {\n        var node = this.startNode();\n        this.expect(types.parenL);\n        node.typeAnnotation = this.tsParseType();\n        this.expect(types.parenR);\n        return this.finishNode(node, \"TSParenthesizedType\");\n      }\n    }, {\n      key: \"tsParseFunctionOrConstructorType\",\n      value: function tsParseFunctionOrConstructorType(type) {\n        var node = this.startNode();\n\n        if (type === \"TSConstructorType\") {\n          this.expect(types._new);\n        }\n\n        this.tsFillSignature(types.arrow, node);\n        return this.finishNode(node, type);\n      }\n    }, {\n      key: \"tsParseLiteralTypeNode\",\n      value: function tsParseLiteralTypeNode() {\n        var _this19 = this;\n\n        var node = this.startNode();\n\n        node.literal = function () {\n          switch (_this19.state.type) {\n            case types.num:\n            case types.bigint:\n            case types.string:\n            case types._true:\n            case types._false:\n              return _this19.parseExprAtom();\n\n            default:\n              throw _this19.unexpected();\n          }\n        }();\n\n        return this.finishNode(node, \"TSLiteralType\");\n      }\n    }, {\n      key: \"tsParseTemplateLiteralType\",\n      value: function tsParseTemplateLiteralType() {\n        var node = this.startNode();\n        var templateNode = this.parseTemplate(false);\n\n        if (templateNode.expressions.length > 0) {\n          this.raise(templateNode.expressions[0].start, TSErrors.TemplateTypeHasSubstitution);\n        }\n\n        node.literal = templateNode;\n        return this.finishNode(node, \"TSLiteralType\");\n      }\n    }, {\n      key: \"tsParseThisTypeOrThisTypePredicate\",\n      value: function tsParseThisTypeOrThisTypePredicate() {\n        var thisKeyword = this.tsParseThisTypeNode();\n\n        if (this.isContextual(\"is\") && !this.hasPrecedingLineBreak()) {\n          return this.tsParseThisTypePredicate(thisKeyword);\n        } else {\n          return thisKeyword;\n        }\n      }\n    }, {\n      key: \"tsParseNonArrayType\",\n      value: function tsParseNonArrayType() {\n        switch (this.state.type) {\n          case types.name:\n          case types._void:\n          case types._null:\n            {\n              var type = this.match(types._void) ? \"TSVoidKeyword\" : this.match(types._null) ? \"TSNullKeyword\" : keywordTypeFromName(this.state.value);\n\n              if (type !== undefined && this.lookaheadCharCode() !== 46) {\n                var node = this.startNode();\n                this.next();\n                return this.finishNode(node, type);\n              }\n\n              return this.tsParseTypeReference();\n            }\n\n          case types.string:\n          case types.num:\n          case types.bigint:\n          case types._true:\n          case types._false:\n            return this.tsParseLiteralTypeNode();\n\n          case types.plusMin:\n            if (this.state.value === \"-\") {\n              var _node6 = this.startNode();\n\n              var nextToken = this.lookahead();\n\n              if (nextToken.type !== types.num && nextToken.type !== types.bigint) {\n                throw this.unexpected();\n              }\n\n              _node6.literal = this.parseMaybeUnary();\n              return this.finishNode(_node6, \"TSLiteralType\");\n            }\n\n            break;\n\n          case types._this:\n            return this.tsParseThisTypeOrThisTypePredicate();\n\n          case types._typeof:\n            return this.tsParseTypeQuery();\n\n          case types._import:\n            return this.tsParseImportType();\n\n          case types.braceL:\n            return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();\n\n          case types.bracketL:\n            return this.tsParseTupleType();\n\n          case types.parenL:\n            return this.tsParseParenthesizedType();\n\n          case types.backQuote:\n            return this.tsParseTemplateLiteralType();\n        }\n\n        throw this.unexpected();\n      }\n    }, {\n      key: \"tsParseArrayTypeOrHigher\",\n      value: function tsParseArrayTypeOrHigher() {\n        var type = this.tsParseNonArrayType();\n\n        while (!this.hasPrecedingLineBreak() && this.eat(types.bracketL)) {\n          if (this.match(types.bracketR)) {\n            var node = this.startNodeAtNode(type);\n            node.elementType = type;\n            this.expect(types.bracketR);\n            type = this.finishNode(node, \"TSArrayType\");\n          } else {\n            var _node7 = this.startNodeAtNode(type);\n\n            _node7.objectType = type;\n            _node7.indexType = this.tsParseType();\n            this.expect(types.bracketR);\n            type = this.finishNode(_node7, \"TSIndexedAccessType\");\n          }\n        }\n\n        return type;\n      }\n    }, {\n      key: \"tsParseTypeOperator\",\n      value: function tsParseTypeOperator(operator) {\n        var node = this.startNode();\n        this.expectContextual(operator);\n        node.operator = operator;\n        node.typeAnnotation = this.tsParseTypeOperatorOrHigher();\n\n        if (operator === \"readonly\") {\n          this.tsCheckTypeAnnotationForReadOnly(node);\n        }\n\n        return this.finishNode(node, \"TSTypeOperator\");\n      }\n    }, {\n      key: \"tsCheckTypeAnnotationForReadOnly\",\n      value: function tsCheckTypeAnnotationForReadOnly(node) {\n        switch (node.typeAnnotation.type) {\n          case \"TSTupleType\":\n          case \"TSArrayType\":\n            return;\n\n          default:\n            this.raise(node.start, TSErrors.UnexpectedReadonly);\n        }\n      }\n    }, {\n      key: \"tsParseInferType\",\n      value: function tsParseInferType() {\n        var node = this.startNode();\n        this.expectContextual(\"infer\");\n        var typeParameter = this.startNode();\n        typeParameter.name = this.parseIdentifierName(typeParameter.start);\n        node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n        return this.finishNode(node, \"TSInferType\");\n      }\n    }, {\n      key: \"tsParseTypeOperatorOrHigher\",\n      value: function tsParseTypeOperatorOrHigher() {\n        var _this20 = this;\n\n        var operator = [\"keyof\", \"unique\", \"readonly\"].find(function (kw) {\n          return _this20.isContextual(kw);\n        });\n        return operator ? this.tsParseTypeOperator(operator) : this.isContextual(\"infer\") ? this.tsParseInferType() : this.tsParseArrayTypeOrHigher();\n      }\n    }, {\n      key: \"tsParseUnionOrIntersectionType\",\n      value: function tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {\n        this.eat(operator);\n        var type = parseConstituentType();\n\n        if (this.match(operator)) {\n          var _types = [type];\n\n          while (this.eat(operator)) {\n            _types.push(parseConstituentType());\n          }\n\n          var node = this.startNodeAtNode(type);\n          node.types = _types;\n          type = this.finishNode(node, kind);\n        }\n\n        return type;\n      }\n    }, {\n      key: \"tsParseIntersectionTypeOrHigher\",\n      value: function tsParseIntersectionTypeOrHigher() {\n        return this.tsParseUnionOrIntersectionType(\"TSIntersectionType\", this.tsParseTypeOperatorOrHigher.bind(this), types.bitwiseAND);\n      }\n    }, {\n      key: \"tsParseUnionTypeOrHigher\",\n      value: function tsParseUnionTypeOrHigher() {\n        return this.tsParseUnionOrIntersectionType(\"TSUnionType\", this.tsParseIntersectionTypeOrHigher.bind(this), types.bitwiseOR);\n      }\n    }, {\n      key: \"tsIsStartOfFunctionType\",\n      value: function tsIsStartOfFunctionType() {\n        if (this.isRelational(\"<\")) {\n          return true;\n        }\n\n        return this.match(types.parenL) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));\n      }\n    }, {\n      key: \"tsSkipParameterStart\",\n      value: function tsSkipParameterStart() {\n        if (this.match(types.name) || this.match(types._this)) {\n          this.next();\n          return true;\n        }\n\n        if (this.match(types.braceL)) {\n          var braceStackCounter = 1;\n          this.next();\n\n          while (braceStackCounter > 0) {\n            if (this.match(types.braceL)) {\n              ++braceStackCounter;\n            } else if (this.match(types.braceR)) {\n              --braceStackCounter;\n            }\n\n            this.next();\n          }\n\n          return true;\n        }\n\n        if (this.match(types.bracketL)) {\n          var _braceStackCounter = 1;\n          this.next();\n\n          while (_braceStackCounter > 0) {\n            if (this.match(types.bracketL)) {\n              ++_braceStackCounter;\n            } else if (this.match(types.bracketR)) {\n              --_braceStackCounter;\n            }\n\n            this.next();\n          }\n\n          return true;\n        }\n\n        return false;\n      }\n    }, {\n      key: \"tsIsUnambiguouslyStartOfFunctionType\",\n      value: function tsIsUnambiguouslyStartOfFunctionType() {\n        this.next();\n\n        if (this.match(types.parenR) || this.match(types.ellipsis)) {\n          return true;\n        }\n\n        if (this.tsSkipParameterStart()) {\n          if (this.match(types.colon) || this.match(types.comma) || this.match(types.question) || this.match(types.eq)) {\n            return true;\n          }\n\n          if (this.match(types.parenR)) {\n            this.next();\n\n            if (this.match(types.arrow)) {\n              return true;\n            }\n          }\n        }\n\n        return false;\n      }\n    }, {\n      key: \"tsParseTypeOrTypePredicateAnnotation\",\n      value: function tsParseTypeOrTypePredicateAnnotation(returnToken) {\n        var _this21 = this;\n\n        return this.tsInType(function () {\n          var t = _this21.startNode();\n\n          _this21.expect(returnToken);\n\n          var asserts = _this21.tsTryParse(_this21.tsParseTypePredicateAsserts.bind(_this21));\n\n          if (asserts && _this21.match(types._this)) {\n            var thisTypePredicate = _this21.tsParseThisTypeOrThisTypePredicate();\n\n            if (thisTypePredicate.type === \"TSThisType\") {\n              var _node8 = _this21.startNodeAtNode(t);\n\n              _node8.parameterName = thisTypePredicate;\n              _node8.asserts = true;\n              thisTypePredicate = _this21.finishNode(_node8, \"TSTypePredicate\");\n            } else {\n              thisTypePredicate.asserts = true;\n            }\n\n            t.typeAnnotation = thisTypePredicate;\n            return _this21.finishNode(t, \"TSTypeAnnotation\");\n          }\n\n          var typePredicateVariable = _this21.tsIsIdentifier() && _this21.tsTryParse(_this21.tsParseTypePredicatePrefix.bind(_this21));\n\n          if (!typePredicateVariable) {\n            if (!asserts) {\n              return _this21.tsParseTypeAnnotation(false, t);\n            }\n\n            var _node9 = _this21.startNodeAtNode(t);\n\n            _node9.parameterName = _this21.parseIdentifier();\n            _node9.asserts = asserts;\n            t.typeAnnotation = _this21.finishNode(_node9, \"TSTypePredicate\");\n            return _this21.finishNode(t, \"TSTypeAnnotation\");\n          }\n\n          var type = _this21.tsParseTypeAnnotation(false);\n\n          var node = _this21.startNodeAtNode(t);\n\n          node.parameterName = typePredicateVariable;\n          node.typeAnnotation = type;\n          node.asserts = asserts;\n          t.typeAnnotation = _this21.finishNode(node, \"TSTypePredicate\");\n          return _this21.finishNode(t, \"TSTypeAnnotation\");\n        });\n      }\n    }, {\n      key: \"tsTryParseTypeOrTypePredicateAnnotation\",\n      value: function tsTryParseTypeOrTypePredicateAnnotation() {\n        return this.match(types.colon) ? this.tsParseTypeOrTypePredicateAnnotation(types.colon) : undefined;\n      }\n    }, {\n      key: \"tsTryParseTypeAnnotation\",\n      value: function tsTryParseTypeAnnotation() {\n        return this.match(types.colon) ? this.tsParseTypeAnnotation() : undefined;\n      }\n    }, {\n      key: \"tsTryParseType\",\n      value: function tsTryParseType() {\n        return this.tsEatThenParseType(types.colon);\n      }\n    }, {\n      key: \"tsParseTypePredicatePrefix\",\n      value: function tsParseTypePredicatePrefix() {\n        var id = this.parseIdentifier();\n\n        if (this.isContextual(\"is\") && !this.hasPrecedingLineBreak()) {\n          this.next();\n          return id;\n        }\n      }\n    }, {\n      key: \"tsParseTypePredicateAsserts\",\n      value: function tsParseTypePredicateAsserts() {\n        if (!this.match(types.name) || this.state.value !== \"asserts\" || this.hasPrecedingLineBreak()) {\n          return false;\n        }\n\n        var containsEsc = this.state.containsEsc;\n        this.next();\n\n        if (!this.match(types.name) && !this.match(types._this)) {\n          return false;\n        }\n\n        if (containsEsc) {\n          this.raise(this.state.lastTokStart, ErrorMessages.InvalidEscapedReservedWord, \"asserts\");\n        }\n\n        return true;\n      }\n    }, {\n      key: \"tsParseTypeAnnotation\",\n      value: function tsParseTypeAnnotation() {\n        var _this22 = this;\n\n        var eatColon = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.startNode();\n        this.tsInType(function () {\n          if (eatColon) _this22.expect(types.colon);\n          t.typeAnnotation = _this22.tsParseType();\n        });\n        return this.finishNode(t, \"TSTypeAnnotation\");\n      }\n    }, {\n      key: \"tsParseType\",\n      value: function tsParseType() {\n        assert(this.state.inType);\n        var type = this.tsParseNonConditionalType();\n\n        if (this.hasPrecedingLineBreak() || !this.eat(types._extends)) {\n          return type;\n        }\n\n        var node = this.startNodeAtNode(type);\n        node.checkType = type;\n        node.extendsType = this.tsParseNonConditionalType();\n        this.expect(types.question);\n        node.trueType = this.tsParseType();\n        this.expect(types.colon);\n        node.falseType = this.tsParseType();\n        return this.finishNode(node, \"TSConditionalType\");\n      }\n    }, {\n      key: \"tsParseNonConditionalType\",\n      value: function tsParseNonConditionalType() {\n        if (this.tsIsStartOfFunctionType()) {\n          return this.tsParseFunctionOrConstructorType(\"TSFunctionType\");\n        }\n\n        if (this.match(types._new)) {\n          return this.tsParseFunctionOrConstructorType(\"TSConstructorType\");\n        }\n\n        return this.tsParseUnionTypeOrHigher();\n      }\n    }, {\n      key: \"tsParseTypeAssertion\",\n      value: function tsParseTypeAssertion() {\n        var node = this.startNode();\n\n        var _const = this.tsTryNextParseConstantContext();\n\n        node.typeAnnotation = _const || this.tsNextThenParseType();\n        this.expectRelational(\">\");\n        node.expression = this.parseMaybeUnary();\n        return this.finishNode(node, \"TSTypeAssertion\");\n      }\n    }, {\n      key: \"tsParseHeritageClause\",\n      value: function tsParseHeritageClause(descriptor) {\n        var originalStart = this.state.start;\n        var delimitedList = this.tsParseDelimitedList(\"HeritageClauseElement\", this.tsParseExpressionWithTypeArguments.bind(this));\n\n        if (!delimitedList.length) {\n          this.raise(originalStart, TSErrors.EmptyHeritageClauseType, descriptor);\n        }\n\n        return delimitedList;\n      }\n    }, {\n      key: \"tsParseExpressionWithTypeArguments\",\n      value: function tsParseExpressionWithTypeArguments() {\n        var node = this.startNode();\n        node.expression = this.tsParseEntityName(false);\n\n        if (this.isRelational(\"<\")) {\n          node.typeParameters = this.tsParseTypeArguments();\n        }\n\n        return this.finishNode(node, \"TSExpressionWithTypeArguments\");\n      }\n    }, {\n      key: \"tsParseInterfaceDeclaration\",\n      value: function tsParseInterfaceDeclaration(node) {\n        node.id = this.parseIdentifier();\n        this.checkLVal(node.id, BIND_TS_INTERFACE, undefined, \"typescript interface declaration\");\n        node.typeParameters = this.tsTryParseTypeParameters();\n\n        if (this.eat(types._extends)) {\n          node.extends = this.tsParseHeritageClause(\"extends\");\n        }\n\n        var body = this.startNode();\n        body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));\n        node.body = this.finishNode(body, \"TSInterfaceBody\");\n        return this.finishNode(node, \"TSInterfaceDeclaration\");\n      }\n    }, {\n      key: \"tsParseTypeAliasDeclaration\",\n      value: function tsParseTypeAliasDeclaration(node) {\n        node.id = this.parseIdentifier();\n        this.checkLVal(node.id, BIND_TS_TYPE, undefined, \"typescript type alias\");\n        node.typeParameters = this.tsTryParseTypeParameters();\n        node.typeAnnotation = this.tsExpectThenParseType(types.eq);\n        this.semicolon();\n        return this.finishNode(node, \"TSTypeAliasDeclaration\");\n      }\n    }, {\n      key: \"tsInNoContext\",\n      value: function tsInNoContext(cb) {\n        var oldContext = this.state.context;\n        this.state.context = [oldContext[0]];\n\n        try {\n          return cb();\n        } finally {\n          this.state.context = oldContext;\n        }\n      }\n    }, {\n      key: \"tsInType\",\n      value: function tsInType(cb) {\n        var oldInType = this.state.inType;\n        this.state.inType = true;\n\n        try {\n          return cb();\n        } finally {\n          this.state.inType = oldInType;\n        }\n      }\n    }, {\n      key: \"tsEatThenParseType\",\n      value: function tsEatThenParseType(token) {\n        return !this.match(token) ? undefined : this.tsNextThenParseType();\n      }\n    }, {\n      key: \"tsExpectThenParseType\",\n      value: function tsExpectThenParseType(token) {\n        var _this23 = this;\n\n        return this.tsDoThenParseType(function () {\n          return _this23.expect(token);\n        });\n      }\n    }, {\n      key: \"tsNextThenParseType\",\n      value: function tsNextThenParseType() {\n        var _this24 = this;\n\n        return this.tsDoThenParseType(function () {\n          return _this24.next();\n        });\n      }\n    }, {\n      key: \"tsDoThenParseType\",\n      value: function tsDoThenParseType(cb) {\n        var _this25 = this;\n\n        return this.tsInType(function () {\n          cb();\n          return _this25.tsParseType();\n        });\n      }\n    }, {\n      key: \"tsParseEnumMember\",\n      value: function tsParseEnumMember() {\n        var node = this.startNode();\n        node.id = this.match(types.string) ? this.parseExprAtom() : this.parseIdentifier(true);\n\n        if (this.eat(types.eq)) {\n          node.initializer = this.parseMaybeAssignAllowIn();\n        }\n\n        return this.finishNode(node, \"TSEnumMember\");\n      }\n    }, {\n      key: \"tsParseEnumDeclaration\",\n      value: function tsParseEnumDeclaration(node, isConst) {\n        if (isConst) node.const = true;\n        node.id = this.parseIdentifier();\n        this.checkLVal(node.id, isConst ? BIND_TS_CONST_ENUM : BIND_TS_ENUM, undefined, \"typescript enum declaration\");\n        this.expect(types.braceL);\n        node.members = this.tsParseDelimitedList(\"EnumMembers\", this.tsParseEnumMember.bind(this));\n        this.expect(types.braceR);\n        return this.finishNode(node, \"TSEnumDeclaration\");\n      }\n    }, {\n      key: \"tsParseModuleBlock\",\n      value: function tsParseModuleBlock() {\n        var node = this.startNode();\n        this.scope.enter(SCOPE_OTHER);\n        this.expect(types.braceL);\n        this.parseBlockOrModuleBlockBody(node.body = [], undefined, true, types.braceR);\n        this.scope.exit();\n        return this.finishNode(node, \"TSModuleBlock\");\n      }\n    }, {\n      key: \"tsParseModuleOrNamespaceDeclaration\",\n      value: function tsParseModuleOrNamespaceDeclaration(node) {\n        var nested = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n        node.id = this.parseIdentifier();\n\n        if (!nested) {\n          this.checkLVal(node.id, BIND_TS_NAMESPACE, null, \"module or namespace declaration\");\n        }\n\n        if (this.eat(types.dot)) {\n          var inner = this.startNode();\n          this.tsParseModuleOrNamespaceDeclaration(inner, true);\n          node.body = inner;\n        } else {\n          this.scope.enter(SCOPE_TS_MODULE);\n          this.prodParam.enter(PARAM);\n          node.body = this.tsParseModuleBlock();\n          this.prodParam.exit();\n          this.scope.exit();\n        }\n\n        return this.finishNode(node, \"TSModuleDeclaration\");\n      }\n    }, {\n      key: \"tsParseAmbientExternalModuleDeclaration\",\n      value: function tsParseAmbientExternalModuleDeclaration(node) {\n        if (this.isContextual(\"global\")) {\n          node.global = true;\n          node.id = this.parseIdentifier();\n        } else if (this.match(types.string)) {\n          node.id = this.parseExprAtom();\n        } else {\n          this.unexpected();\n        }\n\n        if (this.match(types.braceL)) {\n          this.scope.enter(SCOPE_TS_MODULE);\n          this.prodParam.enter(PARAM);\n          node.body = this.tsParseModuleBlock();\n          this.prodParam.exit();\n          this.scope.exit();\n        } else {\n          this.semicolon();\n        }\n\n        return this.finishNode(node, \"TSModuleDeclaration\");\n      }\n    }, {\n      key: \"tsParseImportEqualsDeclaration\",\n      value: function tsParseImportEqualsDeclaration(node, isExport) {\n        node.isExport = isExport || false;\n        node.id = this.parseIdentifier();\n        this.checkLVal(node.id, BIND_LEXICAL, undefined, \"import equals declaration\");\n        this.expect(types.eq);\n        node.moduleReference = this.tsParseModuleReference();\n        this.semicolon();\n        return this.finishNode(node, \"TSImportEqualsDeclaration\");\n      }\n    }, {\n      key: \"tsIsExternalModuleReference\",\n      value: function tsIsExternalModuleReference() {\n        return this.isContextual(\"require\") && this.lookaheadCharCode() === 40;\n      }\n    }, {\n      key: \"tsParseModuleReference\",\n      value: function tsParseModuleReference() {\n        return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);\n      }\n    }, {\n      key: \"tsParseExternalModuleReference\",\n      value: function tsParseExternalModuleReference() {\n        var node = this.startNode();\n        this.expectContextual(\"require\");\n        this.expect(types.parenL);\n\n        if (!this.match(types.string)) {\n          throw this.unexpected();\n        }\n\n        node.expression = this.parseExprAtom();\n        this.expect(types.parenR);\n        return this.finishNode(node, \"TSExternalModuleReference\");\n      }\n    }, {\n      key: \"tsLookAhead\",\n      value: function tsLookAhead(f) {\n        var state = this.state.clone();\n        var res = f();\n        this.state = state;\n        return res;\n      }\n    }, {\n      key: \"tsTryParseAndCatch\",\n      value: function tsTryParseAndCatch(f) {\n        var result = this.tryParse(function (abort) {\n          return f() || abort();\n        });\n        if (result.aborted || !result.node) return undefined;\n        if (result.error) this.state = result.failState;\n        return result.node;\n      }\n    }, {\n      key: \"tsTryParse\",\n      value: function tsTryParse(f) {\n        var state = this.state.clone();\n        var result = f();\n\n        if (result !== undefined && result !== false) {\n          return result;\n        } else {\n          this.state = state;\n          return undefined;\n        }\n      }\n    }, {\n      key: \"tsTryParseDeclare\",\n      value: function tsTryParseDeclare(nany) {\n        if (this.isLineTerminator()) {\n          return;\n        }\n\n        var starttype = this.state.type;\n        var kind;\n\n        if (this.isContextual(\"let\")) {\n          starttype = types._var;\n          kind = \"let\";\n        }\n\n        switch (starttype) {\n          case types._function:\n            return this.parseFunctionStatement(nany, false, true);\n\n          case types._class:\n            nany.declare = true;\n            return this.parseClass(nany, true, false);\n\n          case types._const:\n            if (this.match(types._const) && this.isLookaheadContextual(\"enum\")) {\n              this.expect(types._const);\n              this.expectContextual(\"enum\");\n              return this.tsParseEnumDeclaration(nany, true);\n            }\n\n          case types._var:\n            kind = kind || this.state.value;\n            return this.parseVarStatement(nany, kind);\n\n          case types.name:\n            {\n              var value = this.state.value;\n\n              if (value === \"global\") {\n                return this.tsParseAmbientExternalModuleDeclaration(nany);\n              } else {\n                return this.tsParseDeclaration(nany, value, true);\n              }\n            }\n        }\n      }\n    }, {\n      key: \"tsTryParseExportDeclaration\",\n      value: function tsTryParseExportDeclaration() {\n        return this.tsParseDeclaration(this.startNode(), this.state.value, true);\n      }\n    }, {\n      key: \"tsParseExpressionStatement\",\n      value: function tsParseExpressionStatement(node, expr) {\n        switch (expr.name) {\n          case \"declare\":\n            {\n              var declaration = this.tsTryParseDeclare(node);\n\n              if (declaration) {\n                declaration.declare = true;\n                return declaration;\n              }\n\n              break;\n            }\n\n          case \"global\":\n            if (this.match(types.braceL)) {\n              this.scope.enter(SCOPE_TS_MODULE);\n              this.prodParam.enter(PARAM);\n              var mod = node;\n              mod.global = true;\n              mod.id = expr;\n              mod.body = this.tsParseModuleBlock();\n              this.scope.exit();\n              this.prodParam.exit();\n              return this.finishNode(mod, \"TSModuleDeclaration\");\n            }\n\n            break;\n\n          default:\n            return this.tsParseDeclaration(node, expr.name, false);\n        }\n      }\n    }, {\n      key: \"tsParseDeclaration\",\n      value: function tsParseDeclaration(node, value, next) {\n        switch (value) {\n          case \"abstract\":\n            if (this.tsCheckLineTerminatorAndMatch(types._class, next)) {\n              var cls = node;\n              cls.abstract = true;\n\n              if (next) {\n                this.next();\n\n                if (!this.match(types._class)) {\n                  this.unexpected(null, types._class);\n                }\n              }\n\n              return this.parseClass(cls, true, false);\n            }\n\n            break;\n\n          case \"enum\":\n            if (next || this.match(types.name)) {\n              if (next) this.next();\n              return this.tsParseEnumDeclaration(node, false);\n            }\n\n            break;\n\n          case \"interface\":\n            if (this.tsCheckLineTerminatorAndMatch(types.name, next)) {\n              if (next) this.next();\n              return this.tsParseInterfaceDeclaration(node);\n            }\n\n            break;\n\n          case \"module\":\n            if (next) this.next();\n\n            if (this.match(types.string)) {\n              return this.tsParseAmbientExternalModuleDeclaration(node);\n            } else if (this.tsCheckLineTerminatorAndMatch(types.name, next)) {\n              return this.tsParseModuleOrNamespaceDeclaration(node);\n            }\n\n            break;\n\n          case \"namespace\":\n            if (this.tsCheckLineTerminatorAndMatch(types.name, next)) {\n              if (next) this.next();\n              return this.tsParseModuleOrNamespaceDeclaration(node);\n            }\n\n            break;\n\n          case \"type\":\n            if (this.tsCheckLineTerminatorAndMatch(types.name, next)) {\n              if (next) this.next();\n              return this.tsParseTypeAliasDeclaration(node);\n            }\n\n            break;\n        }\n      }\n    }, {\n      key: \"tsCheckLineTerminatorAndMatch\",\n      value: function tsCheckLineTerminatorAndMatch(tokenType, next) {\n        return (next || this.match(tokenType)) && !this.isLineTerminator();\n      }\n    }, {\n      key: \"tsTryParseGenericAsyncArrowFunction\",\n      value: function tsTryParseGenericAsyncArrowFunction(startPos, startLoc) {\n        var _this26 = this;\n\n        if (!this.isRelational(\"<\")) {\n          return undefined;\n        }\n\n        var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n        var oldYieldPos = this.state.yieldPos;\n        var oldAwaitPos = this.state.awaitPos;\n        this.state.maybeInArrowParameters = true;\n        this.state.yieldPos = -1;\n        this.state.awaitPos = -1;\n        var res = this.tsTryParseAndCatch(function () {\n          var node = _this26.startNodeAt(startPos, startLoc);\n\n          node.typeParameters = _this26.tsParseTypeParameters();\n\n          _get(_getPrototypeOf(_class4.prototype), \"parseFunctionParams\", _this26).call(_this26, node);\n\n          node.returnType = _this26.tsTryParseTypeOrTypePredicateAnnotation();\n\n          _this26.expect(types.arrow);\n\n          return node;\n        });\n        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n        this.state.yieldPos = oldYieldPos;\n        this.state.awaitPos = oldAwaitPos;\n\n        if (!res) {\n          return undefined;\n        }\n\n        return this.parseArrowExpression(res, null, true);\n      }\n    }, {\n      key: \"tsParseTypeArguments\",\n      value: function tsParseTypeArguments() {\n        var _this27 = this;\n\n        var node = this.startNode();\n        node.params = this.tsInType(function () {\n          return _this27.tsInNoContext(function () {\n            _this27.expectRelational(\"<\");\n\n            return _this27.tsParseDelimitedList(\"TypeParametersOrArguments\", _this27.tsParseType.bind(_this27));\n          });\n        });\n        this.state.exprAllowed = false;\n        this.expectRelational(\">\");\n        return this.finishNode(node, \"TSTypeParameterInstantiation\");\n      }\n    }, {\n      key: \"tsIsDeclarationStart\",\n      value: function tsIsDeclarationStart() {\n        if (this.match(types.name)) {\n          switch (this.state.value) {\n            case \"abstract\":\n            case \"declare\":\n            case \"enum\":\n            case \"interface\":\n            case \"module\":\n            case \"namespace\":\n            case \"type\":\n              return true;\n          }\n        }\n\n        return false;\n      }\n    }, {\n      key: \"isExportDefaultSpecifier\",\n      value: function isExportDefaultSpecifier() {\n        if (this.tsIsDeclarationStart()) return false;\n        return _get(_getPrototypeOf(_class4.prototype), \"isExportDefaultSpecifier\", this).call(this);\n      }\n    }, {\n      key: \"parseAssignableListItem\",\n      value: function parseAssignableListItem(allowModifiers, decorators) {\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        var accessibility;\n        var readonly = false;\n\n        if (allowModifiers) {\n          accessibility = this.parseAccessModifier();\n          readonly = !!this.tsParseModifier([\"readonly\"]);\n        }\n\n        var left = this.parseMaybeDefault();\n        this.parseAssignableListItemTypes(left);\n        var elt = this.parseMaybeDefault(left.start, left.loc.start, left);\n\n        if (accessibility || readonly) {\n          var pp = this.startNodeAt(startPos, startLoc);\n\n          if (decorators.length) {\n            pp.decorators = decorators;\n          }\n\n          if (accessibility) pp.accessibility = accessibility;\n          if (readonly) pp.readonly = readonly;\n\n          if (elt.type !== \"Identifier\" && elt.type !== \"AssignmentPattern\") {\n            this.raise(pp.start, TSErrors.UnsupportedParameterPropertyKind);\n          }\n\n          pp.parameter = elt;\n          return this.finishNode(pp, \"TSParameterProperty\");\n        }\n\n        if (decorators.length) {\n          left.decorators = decorators;\n        }\n\n        return elt;\n      }\n    }, {\n      key: \"parseFunctionBodyAndFinish\",\n      value: function parseFunctionBodyAndFinish(node, type) {\n        var isMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n        if (this.match(types.colon)) {\n          node.returnType = this.tsParseTypeOrTypePredicateAnnotation(types.colon);\n        }\n\n        var bodilessType = type === \"FunctionDeclaration\" ? \"TSDeclareFunction\" : type === \"ClassMethod\" ? \"TSDeclareMethod\" : undefined;\n\n        if (bodilessType && !this.match(types.braceL) && this.isLineTerminator()) {\n          this.finishNode(node, bodilessType);\n          return;\n        }\n\n        _get(_getPrototypeOf(_class4.prototype), \"parseFunctionBodyAndFinish\", this).call(this, node, type, isMethod);\n      }\n    }, {\n      key: \"registerFunctionStatementId\",\n      value: function registerFunctionStatementId(node) {\n        if (!node.body && node.id) {\n          this.checkLVal(node.id, BIND_TS_AMBIENT, null, \"function name\");\n        } else {\n          _get(_getPrototypeOf(_class4.prototype), \"registerFunctionStatementId\", this).apply(this, arguments);\n        }\n      }\n    }, {\n      key: \"parseSubscript\",\n      value: function parseSubscript(base, startPos, startLoc, noCalls, state) {\n        var _this28 = this;\n\n        if (!this.hasPrecedingLineBreak() && this.match(types.bang)) {\n          this.state.exprAllowed = false;\n          this.next();\n          var nonNullExpression = this.startNodeAt(startPos, startLoc);\n          nonNullExpression.expression = base;\n          return this.finishNode(nonNullExpression, \"TSNonNullExpression\");\n        }\n\n        if (this.isRelational(\"<\")) {\n          var result = this.tsTryParseAndCatch(function () {\n            if (!noCalls && _this28.atPossibleAsyncArrow(base)) {\n              var asyncArrowFn = _this28.tsTryParseGenericAsyncArrowFunction(startPos, startLoc);\n\n              if (asyncArrowFn) {\n                return asyncArrowFn;\n              }\n            }\n\n            var node = _this28.startNodeAt(startPos, startLoc);\n\n            node.callee = base;\n\n            var typeArguments = _this28.tsParseTypeArguments();\n\n            if (typeArguments) {\n              if (!noCalls && _this28.eat(types.parenL)) {\n                node.arguments = _this28.parseCallExpressionArguments(types.parenR, false);\n                node.typeParameters = typeArguments;\n                return _this28.finishCallExpression(node, state.optionalChainMember);\n              } else if (_this28.match(types.backQuote)) {\n                var _result = _this28.parseTaggedTemplateExpression(base, startPos, startLoc, state);\n\n                _result.typeParameters = typeArguments;\n                return _result;\n              }\n            }\n\n            _this28.unexpected();\n          });\n          if (result) return result;\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseSubscript\", this).call(this, base, startPos, startLoc, noCalls, state);\n      }\n    }, {\n      key: \"parseNewArguments\",\n      value: function parseNewArguments(node) {\n        var _this29 = this;\n\n        if (this.isRelational(\"<\")) {\n          var typeParameters = this.tsTryParseAndCatch(function () {\n            var args = _this29.tsParseTypeArguments();\n\n            if (!_this29.match(types.parenL)) _this29.unexpected();\n            return args;\n          });\n\n          if (typeParameters) {\n            node.typeParameters = typeParameters;\n          }\n        }\n\n        _get(_getPrototypeOf(_class4.prototype), \"parseNewArguments\", this).call(this, node);\n      }\n    }, {\n      key: \"parseExprOp\",\n      value: function parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {\n        if (nonNull(types._in.binop) > minPrec && !this.hasPrecedingLineBreak() && this.isContextual(\"as\")) {\n          var node = this.startNodeAt(leftStartPos, leftStartLoc);\n          node.expression = left;\n\n          var _const = this.tsTryNextParseConstantContext();\n\n          if (_const) {\n            node.typeAnnotation = _const;\n          } else {\n            node.typeAnnotation = this.tsNextThenParseType();\n          }\n\n          this.finishNode(node, \"TSAsExpression\");\n          this.reScan_lt_gt();\n          return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseExprOp\", this).call(this, left, leftStartPos, leftStartLoc, minPrec);\n      }\n    }, {\n      key: \"checkReservedWord\",\n      value: function checkReservedWord(word, startLoc, checkKeywords, isBinding) {}\n    }, {\n      key: \"checkDuplicateExports\",\n      value: function checkDuplicateExports() {}\n    }, {\n      key: \"parseImport\",\n      value: function parseImport(node) {\n        if (this.match(types.name) || this.match(types.star) || this.match(types.braceL)) {\n          var ahead = this.lookahead();\n\n          if (this.match(types.name) && ahead.type === types.eq) {\n            return this.tsParseImportEqualsDeclaration(node);\n          }\n\n          if (this.isContextual(\"type\") && ahead.type !== types.comma && !(ahead.type === types.name && ahead.value === \"from\")) {\n            node.importKind = \"type\";\n            this.next();\n          } else {\n            node.importKind = \"value\";\n          }\n        }\n\n        var importNode = _get(_getPrototypeOf(_class4.prototype), \"parseImport\", this).call(this, node);\n\n        if (importNode.importKind === \"type\" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === \"ImportDefaultSpecifier\") {\n          this.raise(importNode.start, \"A type-only import can specify a default import or named bindings, but not both.\");\n        }\n\n        return importNode;\n      }\n    }, {\n      key: \"parseExport\",\n      value: function parseExport(node) {\n        if (this.match(types._import)) {\n          this.expect(types._import);\n          return this.tsParseImportEqualsDeclaration(node, true);\n        } else if (this.eat(types.eq)) {\n          var assign = node;\n          assign.expression = this.parseExpression();\n          this.semicolon();\n          return this.finishNode(assign, \"TSExportAssignment\");\n        } else if (this.eatContextual(\"as\")) {\n          var decl = node;\n          this.expectContextual(\"namespace\");\n          decl.id = this.parseIdentifier();\n          this.semicolon();\n          return this.finishNode(decl, \"TSNamespaceExportDeclaration\");\n        } else {\n          if (this.isContextual(\"type\") && this.lookahead().type === types.braceL) {\n            this.next();\n            node.exportKind = \"type\";\n          } else {\n            node.exportKind = \"value\";\n          }\n\n          return _get(_getPrototypeOf(_class4.prototype), \"parseExport\", this).call(this, node);\n        }\n      }\n    }, {\n      key: \"isAbstractClass\",\n      value: function isAbstractClass() {\n        return this.isContextual(\"abstract\") && this.lookahead().type === types._class;\n      }\n    }, {\n      key: \"parseExportDefaultExpression\",\n      value: function parseExportDefaultExpression() {\n        if (this.isAbstractClass()) {\n          var cls = this.startNode();\n          this.next();\n          this.parseClass(cls, true, true);\n          cls.abstract = true;\n          return cls;\n        }\n\n        if (this.state.value === \"interface\") {\n          var result = this.tsParseDeclaration(this.startNode(), this.state.value, true);\n          if (result) return result;\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseExportDefaultExpression\", this).call(this);\n      }\n    }, {\n      key: \"parseStatementContent\",\n      value: function parseStatementContent(context, topLevel) {\n        if (this.state.type === types._const) {\n          var ahead = this.lookahead();\n\n          if (ahead.type === types.name && ahead.value === \"enum\") {\n            var node = this.startNode();\n            this.expect(types._const);\n            this.expectContextual(\"enum\");\n            return this.tsParseEnumDeclaration(node, true);\n          }\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseStatementContent\", this).call(this, context, topLevel);\n      }\n    }, {\n      key: \"parseAccessModifier\",\n      value: function parseAccessModifier() {\n        return this.tsParseModifier([\"public\", \"protected\", \"private\"]);\n      }\n    }, {\n      key: \"parseClassMember\",\n      value: function parseClassMember(classBody, member, state, constructorAllowsSuper) {\n        this.tsParseModifiers(member, [\"declare\"]);\n        var accessibility = this.parseAccessModifier();\n        if (accessibility) member.accessibility = accessibility;\n        this.tsParseModifiers(member, [\"declare\"]);\n\n        _get(_getPrototypeOf(_class4.prototype), \"parseClassMember\", this).call(this, classBody, member, state, constructorAllowsSuper);\n      }\n    }, {\n      key: \"parseClassMemberWithIsStatic\",\n      value: function parseClassMemberWithIsStatic(classBody, member, state, isStatic, constructorAllowsSuper) {\n        this.tsParseModifiers(member, [\"abstract\", \"readonly\", \"declare\"]);\n        var idx = this.tsTryParseIndexSignature(member);\n\n        if (idx) {\n          classBody.body.push(idx);\n\n          if (member.abstract) {\n            this.raise(member.start, TSErrors.IndexSignatureHasAbstract);\n          }\n\n          if (isStatic) {\n            this.raise(member.start, TSErrors.IndexSignatureHasStatic);\n          }\n\n          if (member.accessibility) {\n            this.raise(member.start, TSErrors.IndexSignatureHasAccessibility, member.accessibility);\n          }\n\n          return;\n        }\n\n        _get(_getPrototypeOf(_class4.prototype), \"parseClassMemberWithIsStatic\", this).call(this, classBody, member, state, isStatic, constructorAllowsSuper);\n      }\n    }, {\n      key: \"parsePostMemberNameModifiers\",\n      value: function parsePostMemberNameModifiers(methodOrProp) {\n        var optional = this.eat(types.question);\n        if (optional) methodOrProp.optional = true;\n\n        if (methodOrProp.readonly && this.match(types.parenL)) {\n          this.raise(methodOrProp.start, TSErrors.ClassMethodHasReadonly);\n        }\n\n        if (methodOrProp.declare && this.match(types.parenL)) {\n          this.raise(methodOrProp.start, TSErrors.ClassMethodHasDeclare);\n        }\n      }\n    }, {\n      key: \"parseExpressionStatement\",\n      value: function parseExpressionStatement(node, expr) {\n        var decl = expr.type === \"Identifier\" ? this.tsParseExpressionStatement(node, expr) : undefined;\n        return decl || _get(_getPrototypeOf(_class4.prototype), \"parseExpressionStatement\", this).call(this, node, expr);\n      }\n    }, {\n      key: \"shouldParseExportDeclaration\",\n      value: function shouldParseExportDeclaration() {\n        if (this.tsIsDeclarationStart()) return true;\n        return _get(_getPrototypeOf(_class4.prototype), \"shouldParseExportDeclaration\", this).call(this);\n      }\n    }, {\n      key: \"parseConditional\",\n      value: function parseConditional(expr, startPos, startLoc, refNeedsArrowPos) {\n        var _this30 = this;\n\n        if (!refNeedsArrowPos || !this.match(types.question)) {\n          return _get(_getPrototypeOf(_class4.prototype), \"parseConditional\", this).call(this, expr, startPos, startLoc, refNeedsArrowPos);\n        }\n\n        var result = this.tryParse(function () {\n          return _get(_getPrototypeOf(_class4.prototype), \"parseConditional\", _this30).call(_this30, expr, startPos, startLoc);\n        });\n\n        if (!result.node) {\n          refNeedsArrowPos.start = result.error.pos || this.state.start;\n          return expr;\n        }\n\n        if (result.error) this.state = result.failState;\n        return result.node;\n      }\n    }, {\n      key: \"parseParenItem\",\n      value: function parseParenItem(node, startPos, startLoc) {\n        node = _get(_getPrototypeOf(_class4.prototype), \"parseParenItem\", this).call(this, node, startPos, startLoc);\n\n        if (this.eat(types.question)) {\n          node.optional = true;\n          this.resetEndLocation(node);\n        }\n\n        if (this.match(types.colon)) {\n          var typeCastNode = this.startNodeAt(startPos, startLoc);\n          typeCastNode.expression = node;\n          typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();\n          return this.finishNode(typeCastNode, \"TSTypeCastExpression\");\n        }\n\n        return node;\n      }\n    }, {\n      key: \"parseExportDeclaration\",\n      value: function parseExportDeclaration(node) {\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        var isDeclare = this.eatContextual(\"declare\");\n        var declaration;\n\n        if (this.match(types.name)) {\n          declaration = this.tsTryParseExportDeclaration();\n        }\n\n        if (!declaration) {\n          declaration = _get(_getPrototypeOf(_class4.prototype), \"parseExportDeclaration\", this).call(this, node);\n        }\n\n        if (declaration && (declaration.type === \"TSInterfaceDeclaration\" || declaration.type === \"TSTypeAliasDeclaration\" || isDeclare)) {\n          node.exportKind = \"type\";\n        }\n\n        if (declaration && isDeclare) {\n          this.resetStartLocation(declaration, startPos, startLoc);\n          declaration.declare = true;\n        }\n\n        return declaration;\n      }\n    }, {\n      key: \"parseClassId\",\n      value: function parseClassId(node, isStatement, optionalId) {\n        if ((!isStatement || optionalId) && this.isContextual(\"implements\")) {\n          return;\n        }\n\n        _get(_getPrototypeOf(_class4.prototype), \"parseClassId\", this).call(this, node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);\n\n        var typeParameters = this.tsTryParseTypeParameters();\n        if (typeParameters) node.typeParameters = typeParameters;\n      }\n    }, {\n      key: \"parseClassPropertyAnnotation\",\n      value: function parseClassPropertyAnnotation(node) {\n        if (!node.optional && this.eat(types.bang)) {\n          node.definite = true;\n        }\n\n        var type = this.tsTryParseTypeAnnotation();\n        if (type) node.typeAnnotation = type;\n      }\n    }, {\n      key: \"parseClassProperty\",\n      value: function parseClassProperty(node) {\n        this.parseClassPropertyAnnotation(node);\n\n        if (node.declare && this.match(types.equal)) {\n          this.raise(this.state.start, TSErrors.DeclareClassFieldHasInitializer);\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseClassProperty\", this).call(this, node);\n      }\n    }, {\n      key: \"parseClassPrivateProperty\",\n      value: function parseClassPrivateProperty(node) {\n        if (node.abstract) {\n          this.raise(node.start, TSErrors.PrivateElementHasAbstract);\n        }\n\n        if (node.accessibility) {\n          this.raise(node.start, TSErrors.PrivateElementHasAccessibility, node.accessibility);\n        }\n\n        this.parseClassPropertyAnnotation(node);\n        return _get(_getPrototypeOf(_class4.prototype), \"parseClassPrivateProperty\", this).call(this, node);\n      }\n    }, {\n      key: \"pushClassMethod\",\n      value: function pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n        var typeParameters = this.tsTryParseTypeParameters();\n        if (typeParameters) method.typeParameters = typeParameters;\n\n        _get(_getPrototypeOf(_class4.prototype), \"pushClassMethod\", this).call(this, classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);\n      }\n    }, {\n      key: \"pushClassPrivateMethod\",\n      value: function pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n        var typeParameters = this.tsTryParseTypeParameters();\n        if (typeParameters) method.typeParameters = typeParameters;\n\n        _get(_getPrototypeOf(_class4.prototype), \"pushClassPrivateMethod\", this).call(this, classBody, method, isGenerator, isAsync);\n      }\n    }, {\n      key: \"parseClassSuper\",\n      value: function parseClassSuper(node) {\n        _get(_getPrototypeOf(_class4.prototype), \"parseClassSuper\", this).call(this, node);\n\n        if (node.superClass && this.isRelational(\"<\")) {\n          node.superTypeParameters = this.tsParseTypeArguments();\n        }\n\n        if (this.eatContextual(\"implements\")) {\n          node.implements = this.tsParseHeritageClause(\"implements\");\n        }\n      }\n    }, {\n      key: \"parseObjPropValue\",\n      value: function parseObjPropValue(prop) {\n        var _get2;\n\n        var typeParameters = this.tsTryParseTypeParameters();\n        if (typeParameters) prop.typeParameters = typeParameters;\n\n        for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n          args[_key4 - 1] = arguments[_key4];\n        }\n\n        (_get2 = _get(_getPrototypeOf(_class4.prototype), \"parseObjPropValue\", this)).call.apply(_get2, [this, prop].concat(args));\n      }\n    }, {\n      key: \"parseFunctionParams\",\n      value: function parseFunctionParams(node, allowModifiers) {\n        var typeParameters = this.tsTryParseTypeParameters();\n        if (typeParameters) node.typeParameters = typeParameters;\n\n        _get(_getPrototypeOf(_class4.prototype), \"parseFunctionParams\", this).call(this, node, allowModifiers);\n      }\n    }, {\n      key: \"parseVarId\",\n      value: function parseVarId(decl, kind) {\n        _get(_getPrototypeOf(_class4.prototype), \"parseVarId\", this).call(this, decl, kind);\n\n        if (decl.id.type === \"Identifier\" && this.eat(types.bang)) {\n          decl.definite = true;\n        }\n\n        var type = this.tsTryParseTypeAnnotation();\n\n        if (type) {\n          decl.id.typeAnnotation = type;\n          this.resetEndLocation(decl.id);\n        }\n      }\n    }, {\n      key: \"parseAsyncArrowFromCallExpression\",\n      value: function parseAsyncArrowFromCallExpression(node, call) {\n        if (this.match(types.colon)) {\n          node.returnType = this.tsParseTypeAnnotation();\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseAsyncArrowFromCallExpression\", this).call(this, node, call);\n      }\n    }, {\n      key: \"parseMaybeAssign\",\n      value: function parseMaybeAssign() {\n        var _this31 = this;\n\n        for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n          args[_key5] = arguments[_key5];\n        }\n\n        var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;\n\n        var state;\n        var jsx;\n        var typeCast;\n\n        if (this.match(types.jsxTagStart)) {\n          state = this.state.clone();\n          jsx = this.tryParse(function () {\n            var _get3;\n\n            return (_get3 = _get(_getPrototypeOf(_class4.prototype), \"parseMaybeAssign\", _this31)).call.apply(_get3, [_this31].concat(args));\n          }, state);\n          if (!jsx.error) return jsx.node;\n          var context = this.state.context;\n\n          if (context[context.length - 1] === types$1.j_oTag) {\n            context.length -= 2;\n          } else if (context[context.length - 1] === types$1.j_expr) {\n            context.length -= 1;\n          }\n        }\n\n        if (!((_jsx = jsx) == null ? void 0 : _jsx.error) && !this.isRelational(\"<\")) {\n          var _get4;\n\n          return (_get4 = _get(_getPrototypeOf(_class4.prototype), \"parseMaybeAssign\", this)).call.apply(_get4, [this].concat(args));\n        }\n\n        var typeParameters;\n        state = state || this.state.clone();\n        var arrow = this.tryParse(function (abort) {\n          var _get5;\n\n          var _typeParameters;\n\n          typeParameters = _this31.tsParseTypeParameters();\n\n          var expr = (_get5 = _get(_getPrototypeOf(_class4.prototype), \"parseMaybeAssign\", _this31)).call.apply(_get5, [_this31].concat(args));\n\n          if (expr.type !== \"ArrowFunctionExpression\" || expr.extra && expr.extra.parenthesized) {\n            abort();\n          }\n\n          if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {\n            _this31.resetStartLocationFromNode(expr, typeParameters);\n          }\n\n          expr.typeParameters = typeParameters;\n          return expr;\n        }, state);\n        if (!arrow.error && !arrow.aborted) return arrow.node;\n\n        if (!jsx) {\n          assert(!this.hasPlugin(\"jsx\"));\n          typeCast = this.tryParse(function () {\n            var _get6;\n\n            return (_get6 = _get(_getPrototypeOf(_class4.prototype), \"parseMaybeAssign\", _this31)).call.apply(_get6, [_this31].concat(args));\n          }, state);\n          if (!typeCast.error) return typeCast.node;\n        }\n\n        if ((_jsx2 = jsx) == null ? void 0 : _jsx2.node) {\n          this.state = jsx.failState;\n          return jsx.node;\n        }\n\n        if (arrow.node) {\n          this.state = arrow.failState;\n          return arrow.node;\n        }\n\n        if ((_typeCast = typeCast) == null ? void 0 : _typeCast.node) {\n          this.state = typeCast.failState;\n          return typeCast.node;\n        }\n\n        if ((_jsx3 = jsx) == null ? void 0 : _jsx3.thrown) throw jsx.error;\n        if (arrow.thrown) throw arrow.error;\n        if ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.thrown) throw typeCast.error;\n        throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error);\n      }\n    }, {\n      key: \"parseMaybeUnary\",\n      value: function parseMaybeUnary(refExpressionErrors) {\n        if (!this.hasPlugin(\"jsx\") && this.isRelational(\"<\")) {\n          return this.tsParseTypeAssertion();\n        } else {\n          return _get(_getPrototypeOf(_class4.prototype), \"parseMaybeUnary\", this).call(this, refExpressionErrors);\n        }\n      }\n    }, {\n      key: \"parseArrow\",\n      value: function parseArrow(node) {\n        var _this32 = this;\n\n        if (this.match(types.colon)) {\n          var result = this.tryParse(function (abort) {\n            var returnType = _this32.tsParseTypeOrTypePredicateAnnotation(types.colon);\n\n            if (_this32.canInsertSemicolon() || !_this32.match(types.arrow)) abort();\n            return returnType;\n          });\n          if (result.aborted) return;\n\n          if (!result.thrown) {\n            if (result.error) this.state = result.failState;\n            node.returnType = result.node;\n          }\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseArrow\", this).call(this, node);\n      }\n    }, {\n      key: \"parseAssignableListItemTypes\",\n      value: function parseAssignableListItemTypes(param) {\n        if (this.eat(types.question)) {\n          if (param.type !== \"Identifier\") {\n            this.raise(param.start, TSErrors.PatternIsOptional);\n          }\n\n          param.optional = true;\n        }\n\n        var type = this.tsTryParseTypeAnnotation();\n        if (type) param.typeAnnotation = type;\n        this.resetEndLocation(param);\n        return param;\n      }\n    }, {\n      key: \"toAssignable\",\n      value: function toAssignable(node) {\n        switch (node.type) {\n          case \"TSTypeCastExpression\":\n            return _get(_getPrototypeOf(_class4.prototype), \"toAssignable\", this).call(this, this.typeCastToParameter(node));\n\n          case \"TSParameterProperty\":\n            return _get(_getPrototypeOf(_class4.prototype), \"toAssignable\", this).call(this, node);\n\n          case \"TSAsExpression\":\n          case \"TSNonNullExpression\":\n          case \"TSTypeAssertion\":\n            node.expression = this.toAssignable(node.expression);\n            return node;\n\n          default:\n            return _get(_getPrototypeOf(_class4.prototype), \"toAssignable\", this).call(this, node);\n        }\n      }\n    }, {\n      key: \"checkLVal\",\n      value: function checkLVal(expr) {\n        var bindingType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : BIND_NONE;\n        var checkClashes = arguments.length > 2 ? arguments[2] : undefined;\n        var contextDescription = arguments.length > 3 ? arguments[3] : undefined;\n\n        switch (expr.type) {\n          case \"TSTypeCastExpression\":\n            return;\n\n          case \"TSParameterProperty\":\n            this.checkLVal(expr.parameter, bindingType, checkClashes, \"parameter property\");\n            return;\n\n          case \"TSAsExpression\":\n          case \"TSNonNullExpression\":\n          case \"TSTypeAssertion\":\n            this.checkLVal(expr.expression, bindingType, checkClashes, contextDescription);\n            return;\n\n          default:\n            _get(_getPrototypeOf(_class4.prototype), \"checkLVal\", this).call(this, expr, bindingType, checkClashes, contextDescription);\n\n            return;\n        }\n      }\n    }, {\n      key: \"parseBindingAtom\",\n      value: function parseBindingAtom() {\n        switch (this.state.type) {\n          case types._this:\n            return this.parseIdentifier(true);\n\n          default:\n            return _get(_getPrototypeOf(_class4.prototype), \"parseBindingAtom\", this).call(this);\n        }\n      }\n    }, {\n      key: \"parseMaybeDecoratorArguments\",\n      value: function parseMaybeDecoratorArguments(expr) {\n        if (this.isRelational(\"<\")) {\n          var typeArguments = this.tsParseTypeArguments();\n\n          if (this.match(types.parenL)) {\n            var call = _get(_getPrototypeOf(_class4.prototype), \"parseMaybeDecoratorArguments\", this).call(this, expr);\n\n            call.typeParameters = typeArguments;\n            return call;\n          }\n\n          this.unexpected(this.state.start, types.parenL);\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"parseMaybeDecoratorArguments\", this).call(this, expr);\n      }\n    }, {\n      key: \"isClassMethod\",\n      value: function isClassMethod() {\n        return this.isRelational(\"<\") || _get(_getPrototypeOf(_class4.prototype), \"isClassMethod\", this).call(this);\n      }\n    }, {\n      key: \"isClassProperty\",\n      value: function isClassProperty() {\n        return this.match(types.bang) || this.match(types.colon) || _get(_getPrototypeOf(_class4.prototype), \"isClassProperty\", this).call(this);\n      }\n    }, {\n      key: \"parseMaybeDefault\",\n      value: function parseMaybeDefault() {\n        var _get7;\n\n        for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n          args[_key6] = arguments[_key6];\n        }\n\n        var node = (_get7 = _get(_getPrototypeOf(_class4.prototype), \"parseMaybeDefault\", this)).call.apply(_get7, [this].concat(args));\n\n        if (node.type === \"AssignmentPattern\" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {\n          this.raise(node.typeAnnotation.start, TSErrors.TypeAnnotationAfterAssign);\n        }\n\n        return node;\n      }\n    }, {\n      key: \"getTokenFromCode\",\n      value: function getTokenFromCode(code) {\n        if (this.state.inType && (code === 62 || code === 60)) {\n          return this.finishOp(types.relational, 1);\n        } else {\n          return _get(_getPrototypeOf(_class4.prototype), \"getTokenFromCode\", this).call(this, code);\n        }\n      }\n    }, {\n      key: \"reScan_lt_gt\",\n      value: function reScan_lt_gt() {\n        if (this.match(types.relational)) {\n          var code = this.input.charCodeAt(this.state.start);\n\n          if (code === 60 || code === 62) {\n            this.state.pos -= 1;\n            this.readToken_lt_gt(code);\n          }\n        }\n      }\n    }, {\n      key: \"toAssignableList\",\n      value: function toAssignableList(exprList) {\n        for (var i = 0; i < exprList.length; i++) {\n          var expr = exprList[i];\n          if (!expr) continue;\n\n          switch (expr.type) {\n            case \"TSTypeCastExpression\":\n              exprList[i] = this.typeCastToParameter(expr);\n              break;\n\n            case \"TSAsExpression\":\n            case \"TSTypeAssertion\":\n              if (!this.state.maybeInArrowParameters) {\n                exprList[i] = this.typeCastToParameter(expr);\n              } else {\n                this.raise(expr.start, TSErrors.UnexpectedTypeCastInParameter);\n              }\n\n              break;\n          }\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"toAssignableList\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"typeCastToParameter\",\n      value: function typeCastToParameter(node) {\n        node.expression.typeAnnotation = node.typeAnnotation;\n        this.resetEndLocation(node.expression, node.typeAnnotation.end, node.typeAnnotation.loc.end);\n        return node.expression;\n      }\n    }, {\n      key: \"toReferencedList\",\n      value: function toReferencedList(exprList, isInParens) {\n        for (var i = 0; i < exprList.length; i++) {\n          var expr = exprList[i];\n\n          if ((expr == null ? void 0 : expr.type) === \"TSTypeCastExpression\") {\n            this.raise(expr.start, TSErrors.UnexpectedTypeAnnotation);\n          }\n        }\n\n        return exprList;\n      }\n    }, {\n      key: \"shouldParseArrow\",\n      value: function shouldParseArrow() {\n        return this.match(types.colon) || _get(_getPrototypeOf(_class4.prototype), \"shouldParseArrow\", this).call(this);\n      }\n    }, {\n      key: \"shouldParseAsyncArrow\",\n      value: function shouldParseAsyncArrow() {\n        return this.match(types.colon) || _get(_getPrototypeOf(_class4.prototype), \"shouldParseAsyncArrow\", this).call(this);\n      }\n    }, {\n      key: \"canHaveLeadingDecorator\",\n      value: function canHaveLeadingDecorator() {\n        return _get(_getPrototypeOf(_class4.prototype), \"canHaveLeadingDecorator\", this).call(this) || this.isAbstractClass();\n      }\n    }, {\n      key: \"jsxParseOpeningElementAfterName\",\n      value: function jsxParseOpeningElementAfterName(node) {\n        var _this33 = this;\n\n        if (this.isRelational(\"<\")) {\n          var typeArguments = this.tsTryParseAndCatch(function () {\n            return _this33.tsParseTypeArguments();\n          });\n          if (typeArguments) node.typeParameters = typeArguments;\n        }\n\n        return _get(_getPrototypeOf(_class4.prototype), \"jsxParseOpeningElementAfterName\", this).call(this, node);\n      }\n    }, {\n      key: \"getGetterSetterExpectedParamCount\",\n      value: function getGetterSetterExpectedParamCount(method) {\n        var baseCount = _get(_getPrototypeOf(_class4.prototype), \"getGetterSetterExpectedParamCount\", this).call(this, method);\n\n        var firstParam = method.params[0];\n        var hasContextParam = firstParam && firstParam.type === \"Identifier\" && firstParam.name === \"this\";\n        return hasContextParam ? baseCount + 1 : baseCount;\n      }\n    }, {\n      key: \"parseCatchClauseParam\",\n      value: function parseCatchClauseParam() {\n        var param = _get(_getPrototypeOf(_class4.prototype), \"parseCatchClauseParam\", this).call(this);\n\n        var type = this.tsTryParseTypeAnnotation();\n\n        if (type) {\n          param.typeAnnotation = type;\n          this.resetEndLocation(param);\n        }\n\n        return param;\n      }\n    }]);\n\n    return _class4;\n  }(superClass);\n};\n\ntypes.placeholder = new TokenType(\"%%\", {\n  startsExpr: true\n});\n\nvar placeholders = function placeholders(superClass) {\n  return /*#__PURE__*/function (_superClass5) {\n    _inherits(_class5, _superClass5);\n\n    var _super9 = _createSuper(_class5);\n\n    function _class5() {\n      _classCallCheck(this, _class5);\n\n      return _super9.apply(this, arguments);\n    }\n\n    _createClass(_class5, [{\n      key: \"parsePlaceholder\",\n      value: function parsePlaceholder(expectedNode) {\n        if (this.match(types.placeholder)) {\n          var node = this.startNode();\n          this.next();\n          this.assertNoSpace(\"Unexpected space in placeholder.\");\n          node.name = _get(_getPrototypeOf(_class5.prototype), \"parseIdentifier\", this).call(this, true);\n          this.assertNoSpace(\"Unexpected space in placeholder.\");\n          this.expect(types.placeholder);\n          return this.finishPlaceholder(node, expectedNode);\n        }\n      }\n    }, {\n      key: \"finishPlaceholder\",\n      value: function finishPlaceholder(node, expectedNode) {\n        var isFinished = !!(node.expectedNode && node.type === \"Placeholder\");\n        node.expectedNode = expectedNode;\n        return isFinished ? node : this.finishNode(node, \"Placeholder\");\n      }\n    }, {\n      key: \"getTokenFromCode\",\n      value: function getTokenFromCode(code) {\n        if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {\n          return this.finishOp(types.placeholder, 2);\n        }\n\n        return _get(_getPrototypeOf(_class5.prototype), \"getTokenFromCode\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseExprAtom\",\n      value: function parseExprAtom() {\n        return this.parsePlaceholder(\"Expression\") || _get(_getPrototypeOf(_class5.prototype), \"parseExprAtom\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseIdentifier\",\n      value: function parseIdentifier() {\n        return this.parsePlaceholder(\"Identifier\") || _get(_getPrototypeOf(_class5.prototype), \"parseIdentifier\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"checkReservedWord\",\n      value: function checkReservedWord(word) {\n        if (word !== undefined) _get(_getPrototypeOf(_class5.prototype), \"checkReservedWord\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseBindingAtom\",\n      value: function parseBindingAtom() {\n        return this.parsePlaceholder(\"Pattern\") || _get(_getPrototypeOf(_class5.prototype), \"parseBindingAtom\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"checkLVal\",\n      value: function checkLVal(expr) {\n        if (expr.type !== \"Placeholder\") _get(_getPrototypeOf(_class5.prototype), \"checkLVal\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"toAssignable\",\n      value: function toAssignable(node) {\n        if (node && node.type === \"Placeholder\" && node.expectedNode === \"Expression\") {\n          node.expectedNode = \"Pattern\";\n          return node;\n        }\n\n        return _get(_getPrototypeOf(_class5.prototype), \"toAssignable\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"verifyBreakContinue\",\n      value: function verifyBreakContinue(node) {\n        if (node.label && node.label.type === \"Placeholder\") return;\n\n        _get(_getPrototypeOf(_class5.prototype), \"verifyBreakContinue\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseExpressionStatement\",\n      value: function parseExpressionStatement(node, expr) {\n        if (expr.type !== \"Placeholder\" || expr.extra && expr.extra.parenthesized) {\n          return _get(_getPrototypeOf(_class5.prototype), \"parseExpressionStatement\", this).apply(this, arguments);\n        }\n\n        if (this.match(types.colon)) {\n          var stmt = node;\n          stmt.label = this.finishPlaceholder(expr, \"Identifier\");\n          this.next();\n          stmt.body = this.parseStatement(\"label\");\n          return this.finishNode(stmt, \"LabeledStatement\");\n        }\n\n        this.semicolon();\n        node.name = expr.name;\n        return this.finishPlaceholder(node, \"Statement\");\n      }\n    }, {\n      key: \"parseBlock\",\n      value: function parseBlock() {\n        return this.parsePlaceholder(\"BlockStatement\") || _get(_getPrototypeOf(_class5.prototype), \"parseBlock\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseFunctionId\",\n      value: function parseFunctionId() {\n        return this.parsePlaceholder(\"Identifier\") || _get(_getPrototypeOf(_class5.prototype), \"parseFunctionId\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"parseClass\",\n      value: function parseClass(node, isStatement, optionalId) {\n        var type = isStatement ? \"ClassDeclaration\" : \"ClassExpression\";\n        this.next();\n        this.takeDecorators(node);\n        var oldStrict = this.state.strict;\n        var placeholder = this.parsePlaceholder(\"Identifier\");\n\n        if (placeholder) {\n          if (this.match(types._extends) || this.match(types.placeholder) || this.match(types.braceL)) {\n            node.id = placeholder;\n          } else if (optionalId || !isStatement) {\n            node.id = null;\n            node.body = this.finishPlaceholder(placeholder, \"ClassBody\");\n            return this.finishNode(node, type);\n          } else {\n            this.unexpected(null, \"A class name is required\");\n          }\n        } else {\n          this.parseClassId(node, isStatement, optionalId);\n        }\n\n        this.parseClassSuper(node);\n        node.body = this.parsePlaceholder(\"ClassBody\") || this.parseClassBody(!!node.superClass, oldStrict);\n        return this.finishNode(node, type);\n      }\n    }, {\n      key: \"parseExport\",\n      value: function parseExport(node) {\n        var placeholder = this.parsePlaceholder(\"Identifier\");\n        if (!placeholder) return _get(_getPrototypeOf(_class5.prototype), \"parseExport\", this).apply(this, arguments);\n\n        if (!this.isContextual(\"from\") && !this.match(types.comma)) {\n          node.specifiers = [];\n          node.source = null;\n          node.declaration = this.finishPlaceholder(placeholder, \"Declaration\");\n          return this.finishNode(node, \"ExportNamedDeclaration\");\n        }\n\n        this.expectPlugin(\"exportDefaultFrom\");\n        var specifier = this.startNode();\n        specifier.exported = placeholder;\n        node.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n        return _get(_getPrototypeOf(_class5.prototype), \"parseExport\", this).call(this, node);\n      }\n    }, {\n      key: \"isExportDefaultSpecifier\",\n      value: function isExportDefaultSpecifier() {\n        if (this.match(types._default)) {\n          var next = this.nextTokenStart();\n\n          if (this.isUnparsedContextual(next, \"from\")) {\n            if (this.input.startsWith(types.placeholder.label, this.nextTokenStartSince(next + 4))) {\n              return true;\n            }\n          }\n        }\n\n        return _get(_getPrototypeOf(_class5.prototype), \"isExportDefaultSpecifier\", this).call(this);\n      }\n    }, {\n      key: \"maybeParseExportDefaultSpecifier\",\n      value: function maybeParseExportDefaultSpecifier(node) {\n        if (node.specifiers && node.specifiers.length > 0) {\n          return true;\n        }\n\n        return _get(_getPrototypeOf(_class5.prototype), \"maybeParseExportDefaultSpecifier\", this).apply(this, arguments);\n      }\n    }, {\n      key: \"checkExport\",\n      value: function checkExport(node) {\n        var specifiers = node.specifiers;\n\n        if (specifiers == null ? void 0 : specifiers.length) {\n          node.specifiers = specifiers.filter(function (node) {\n            return node.exported.type === \"Placeholder\";\n          });\n        }\n\n        _get(_getPrototypeOf(_class5.prototype), \"checkExport\", this).call(this, node);\n\n        node.specifiers = specifiers;\n      }\n    }, {\n      key: \"parseImport\",\n      value: function parseImport(node) {\n        var placeholder = this.parsePlaceholder(\"Identifier\");\n        if (!placeholder) return _get(_getPrototypeOf(_class5.prototype), \"parseImport\", this).apply(this, arguments);\n        node.specifiers = [];\n\n        if (!this.isContextual(\"from\") && !this.match(types.comma)) {\n          node.source = this.finishPlaceholder(placeholder, \"StringLiteral\");\n          this.semicolon();\n          return this.finishNode(node, \"ImportDeclaration\");\n        }\n\n        var specifier = this.startNodeAtNode(placeholder);\n        specifier.local = placeholder;\n        this.finishNode(specifier, \"ImportDefaultSpecifier\");\n        node.specifiers.push(specifier);\n\n        if (this.eat(types.comma)) {\n          var hasStarImport = this.maybeParseStarImportSpecifier(node);\n          if (!hasStarImport) this.parseNamedImportSpecifiers(node);\n        }\n\n        this.expectContextual(\"from\");\n        node.source = this.parseImportSource();\n        this.semicolon();\n        return this.finishNode(node, \"ImportDeclaration\");\n      }\n    }, {\n      key: \"parseImportSource\",\n      value: function parseImportSource() {\n        return this.parsePlaceholder(\"StringLiteral\") || _get(_getPrototypeOf(_class5.prototype), \"parseImportSource\", this).apply(this, arguments);\n      }\n    }]);\n\n    return _class5;\n  }(superClass);\n};\n\nvar v8intrinsic = function v8intrinsic(superClass) {\n  return /*#__PURE__*/function (_superClass6) {\n    _inherits(_class6, _superClass6);\n\n    var _super10 = _createSuper(_class6);\n\n    function _class6() {\n      _classCallCheck(this, _class6);\n\n      return _super10.apply(this, arguments);\n    }\n\n    _createClass(_class6, [{\n      key: \"parseV8Intrinsic\",\n      value: function parseV8Intrinsic() {\n        if (this.match(types.modulo)) {\n          var v8IntrinsicStart = this.state.start;\n          var node = this.startNode();\n          this.eat(types.modulo);\n\n          if (this.match(types.name)) {\n            var name = this.parseIdentifierName(this.state.start);\n            var identifier = this.createIdentifier(node, name);\n            identifier.type = \"V8IntrinsicIdentifier\";\n\n            if (this.match(types.parenL)) {\n              return identifier;\n            }\n          }\n\n          this.unexpected(v8IntrinsicStart);\n        }\n      }\n    }, {\n      key: \"parseExprAtom\",\n      value: function parseExprAtom() {\n        return this.parseV8Intrinsic() || _get(_getPrototypeOf(_class6.prototype), \"parseExprAtom\", this).apply(this, arguments);\n      }\n    }]);\n\n    return _class6;\n  }(superClass);\n};\n\nfunction hasPlugin(plugins, name) {\n  return plugins.some(function (plugin) {\n    if (Array.isArray(plugin)) {\n      return plugin[0] === name;\n    } else {\n      return plugin === name;\n    }\n  });\n}\n\nfunction getPluginOption(plugins, name, option) {\n  var plugin = plugins.find(function (plugin) {\n    if (Array.isArray(plugin)) {\n      return plugin[0] === name;\n    } else {\n      return plugin === name;\n    }\n  });\n\n  if (plugin && Array.isArray(plugin)) {\n    return plugin[1][option];\n  }\n\n  return null;\n}\n\nvar PIPELINE_PROPOSALS = [\"minimal\", \"smart\", \"fsharp\"];\nvar RECORD_AND_TUPLE_SYNTAX_TYPES = [\"hash\", \"bar\"];\n\nfunction validatePlugins(plugins) {\n  if (hasPlugin(plugins, \"decorators\")) {\n    if (hasPlugin(plugins, \"decorators-legacy\")) {\n      throw new Error(\"Cannot use the decorators and decorators-legacy plugin together\");\n    }\n\n    var decoratorsBeforeExport = getPluginOption(plugins, \"decorators\", \"decoratorsBeforeExport\");\n\n    if (decoratorsBeforeExport == null) {\n      throw new Error(\"The 'decorators' plugin requires a 'decoratorsBeforeExport' option,\" + \" whose value must be a boolean. If you are migrating from\" + \" Babylon/Babel 6 or want to use the old decorators proposal, you\" + \" should use the 'decorators-legacy' plugin instead of 'decorators'.\");\n    } else if (typeof decoratorsBeforeExport !== \"boolean\") {\n      throw new Error(\"'decoratorsBeforeExport' must be a boolean.\");\n    }\n  }\n\n  if (hasPlugin(plugins, \"flow\") && hasPlugin(plugins, \"typescript\")) {\n    throw new Error(\"Cannot combine flow and typescript plugins.\");\n  }\n\n  if (hasPlugin(plugins, \"placeholders\") && hasPlugin(plugins, \"v8intrinsic\")) {\n    throw new Error(\"Cannot combine placeholders and v8intrinsic plugins.\");\n  }\n\n  if (hasPlugin(plugins, \"pipelineOperator\") && !PIPELINE_PROPOSALS.includes(getPluginOption(plugins, \"pipelineOperator\", \"proposal\"))) {\n    throw new Error(\"'pipelineOperator' requires 'proposal' option whose value should be one of: \" + PIPELINE_PROPOSALS.map(function (p) {\n      return \"'\".concat(p, \"'\");\n    }).join(\", \"));\n  }\n\n  if (hasPlugin(plugins, \"moduleAttributes\")) {\n    var moduleAttributesVerionPluginOption = getPluginOption(plugins, \"moduleAttributes\", \"version\");\n\n    if (moduleAttributesVerionPluginOption !== \"may-2020\") {\n      throw new Error(\"The 'moduleAttributes' plugin requires a 'version' option,\" + \" representing the last proposal update. Currently, the\" + \" only supported value is 'may-2020'.\");\n    }\n  }\n\n  if (hasPlugin(plugins, \"recordAndTuple\") && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, \"recordAndTuple\", \"syntaxType\"))) {\n    throw new Error(\"'recordAndTuple' requires 'syntaxType' option whose value should be one of: \" + RECORD_AND_TUPLE_SYNTAX_TYPES.map(function (p) {\n      return \"'\".concat(p, \"'\");\n    }).join(\", \"));\n  }\n}\n\nvar mixinPlugins = {\n  estree: estree,\n  jsx: jsx,\n  flow: flow,\n  typescript: typescript,\n  v8intrinsic: v8intrinsic,\n  placeholders: placeholders\n};\nvar mixinPluginNames = Object.keys(mixinPlugins);\nvar defaultOptions = {\n  sourceType: \"script\",\n  sourceFilename: undefined,\n  startLine: 1,\n  allowAwaitOutsideFunction: false,\n  allowReturnOutsideFunction: false,\n  allowImportExportEverywhere: false,\n  allowSuperOutsideMethod: false,\n  allowUndeclaredExports: false,\n  plugins: [],\n  strictMode: null,\n  ranges: false,\n  tokens: false,\n  createParenthesizedExpressions: false,\n  errorRecovery: false\n};\n\nfunction getOptions(opts) {\n  var options = {};\n\n  for (var _i = 0, _Object$keys = Object.keys(defaultOptions); _i < _Object$keys.length; _i++) {\n    var key = _Object$keys[_i];\n    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];\n  }\n\n  return options;\n}\n\nvar State = /*#__PURE__*/function () {\n  function State() {\n    _classCallCheck(this, State);\n\n    this.errors = [];\n    this.potentialArrowAt = -1;\n    this.noArrowAt = [];\n    this.noArrowParamsConversionAt = [];\n    this.inParameters = false;\n    this.maybeInArrowParameters = false;\n    this.maybeInAsyncArrowHead = false;\n    this.inPipeline = false;\n    this.inType = false;\n    this.noAnonFunctionType = false;\n    this.inPropertyName = false;\n    this.hasFlowComment = false;\n    this.isIterator = false;\n    this.topicContext = {\n      maxNumOfResolvableTopics: 0,\n      maxTopicIndex: null\n    };\n    this.soloAwait = false;\n    this.inFSharpPipelineDirectBody = false;\n    this.labels = [];\n    this.decoratorStack = [[]];\n    this.yieldPos = -1;\n    this.awaitPos = -1;\n    this.comments = [];\n    this.trailingComments = [];\n    this.leadingComments = [];\n    this.commentStack = [];\n    this.commentPreviousNode = null;\n    this.pos = 0;\n    this.lineStart = 0;\n    this.type = types.eof;\n    this.value = null;\n    this.start = 0;\n    this.end = 0;\n    this.lastTokEndLoc = null;\n    this.lastTokStartLoc = null;\n    this.lastTokStart = 0;\n    this.lastTokEnd = 0;\n    this.context = [types$1.braceStatement];\n    this.exprAllowed = true;\n    this.containsEsc = false;\n    this.octalPositions = [];\n    this.exportedIdentifiers = [];\n    this.tokensLength = 0;\n  }\n\n  _createClass(State, [{\n    key: \"init\",\n    value: function init(options) {\n      this.strict = options.strictMode === false ? false : options.sourceType === \"module\";\n      this.curLine = options.startLine;\n      this.startLoc = this.endLoc = this.curPosition();\n    }\n  }, {\n    key: \"curPosition\",\n    value: function curPosition() {\n      return new Position(this.curLine, this.pos - this.lineStart);\n    }\n  }, {\n    key: \"clone\",\n    value: function clone(skipArrays) {\n      var state = new State();\n      var keys = Object.keys(this);\n\n      for (var i = 0, length = keys.length; i < length; i++) {\n        var key = keys[i];\n        var val = this[key];\n\n        if (!skipArrays && Array.isArray(val)) {\n          val = val.slice();\n        }\n\n        state[key] = val;\n      }\n\n      return state;\n    }\n  }]);\n\n  return State;\n}();\n\nvar _isDigit = function isDigit(code) {\n  return code >= 48 && code <= 57;\n};\n\nvar VALID_REGEX_FLAGS = new Set([\"g\", \"m\", \"s\", \"i\", \"y\", \"u\"]);\nvar forbiddenNumericSeparatorSiblings = {\n  decBinOct: [46, 66, 69, 79, 95, 98, 101, 111],\n  hex: [46, 88, 95, 120]\n};\nvar allowedNumericSeparatorSiblings = {};\nallowedNumericSeparatorSiblings.bin = [48, 49];\nallowedNumericSeparatorSiblings.oct = [].concat(_toConsumableArray(allowedNumericSeparatorSiblings.bin), [50, 51, 52, 53, 54, 55]);\nallowedNumericSeparatorSiblings.dec = [].concat(_toConsumableArray(allowedNumericSeparatorSiblings.oct), [56, 57]);\nallowedNumericSeparatorSiblings.hex = [].concat(_toConsumableArray(allowedNumericSeparatorSiblings.dec), [65, 66, 67, 68, 69, 70, 97, 98, 99, 100, 101, 102]);\n\nvar Token = function Token(state) {\n  _classCallCheck(this, Token);\n\n  this.type = state.type;\n  this.value = state.value;\n  this.start = state.start;\n  this.end = state.end;\n  this.loc = new SourceLocation(state.startLoc, state.endLoc);\n};\n\nvar Tokenizer = /*#__PURE__*/function (_ParserError) {\n  _inherits(Tokenizer, _ParserError);\n\n  var _super11 = _createSuper(Tokenizer);\n\n  function Tokenizer(options, input) {\n    var _this34;\n\n    _classCallCheck(this, Tokenizer);\n\n    _this34 = _super11.call(this);\n    _this34.tokens = [];\n    _this34.state = new State();\n\n    _this34.state.init(options);\n\n    _this34.input = input;\n    _this34.length = input.length;\n    _this34.isLookahead = false;\n    return _this34;\n  }\n\n  _createClass(Tokenizer, [{\n    key: \"pushToken\",\n    value: function pushToken(token) {\n      this.tokens.length = this.state.tokensLength;\n      this.tokens.push(token);\n      ++this.state.tokensLength;\n    }\n  }, {\n    key: \"next\",\n    value: function next() {\n      if (!this.isLookahead) {\n        this.checkKeywordEscapes();\n\n        if (this.options.tokens) {\n          this.pushToken(new Token(this.state));\n        }\n      }\n\n      this.state.lastTokEnd = this.state.end;\n      this.state.lastTokStart = this.state.start;\n      this.state.lastTokEndLoc = this.state.endLoc;\n      this.state.lastTokStartLoc = this.state.startLoc;\n      this.nextToken();\n    }\n  }, {\n    key: \"eat\",\n    value: function eat(type) {\n      if (this.match(type)) {\n        this.next();\n        return true;\n      } else {\n        return false;\n      }\n    }\n  }, {\n    key: \"match\",\n    value: function match(type) {\n      return this.state.type === type;\n    }\n  }, {\n    key: \"lookahead\",\n    value: function lookahead() {\n      var old = this.state;\n      this.state = old.clone(true);\n      this.isLookahead = true;\n      this.next();\n      this.isLookahead = false;\n      var curr = this.state;\n      this.state = old;\n      return curr;\n    }\n  }, {\n    key: \"nextTokenStart\",\n    value: function nextTokenStart() {\n      return this.nextTokenStartSince(this.state.pos);\n    }\n  }, {\n    key: \"nextTokenStartSince\",\n    value: function nextTokenStartSince(pos) {\n      skipWhiteSpace.lastIndex = pos;\n      var skip = skipWhiteSpace.exec(this.input);\n      return pos + skip[0].length;\n    }\n  }, {\n    key: \"lookaheadCharCode\",\n    value: function lookaheadCharCode() {\n      return this.input.charCodeAt(this.nextTokenStart());\n    }\n  }, {\n    key: \"setStrict\",\n    value: function setStrict(strict) {\n      this.state.strict = strict;\n      if (!this.match(types.num) && !this.match(types.string)) return;\n      this.state.pos = this.state.start;\n\n      while (this.state.pos < this.state.lineStart) {\n        this.state.lineStart = this.input.lastIndexOf(\"\\n\", this.state.lineStart - 2) + 1;\n        --this.state.curLine;\n      }\n\n      this.nextToken();\n    }\n  }, {\n    key: \"curContext\",\n    value: function curContext() {\n      return this.state.context[this.state.context.length - 1];\n    }\n  }, {\n    key: \"nextToken\",\n    value: function nextToken() {\n      var curContext = this.curContext();\n      if (!(curContext == null ? void 0 : curContext.preserveSpace)) this.skipSpace();\n      this.state.octalPositions = [];\n      this.state.start = this.state.pos;\n      this.state.startLoc = this.state.curPosition();\n\n      if (this.state.pos >= this.length) {\n        this.finishToken(types.eof);\n        return;\n      }\n\n      var override = curContext == null ? void 0 : curContext.override;\n\n      if (override) {\n        override(this);\n      } else {\n        this.getTokenFromCode(this.input.codePointAt(this.state.pos));\n      }\n    }\n  }, {\n    key: \"pushComment\",\n    value: function pushComment(block, text, start, end, startLoc, endLoc) {\n      var comment = {\n        type: block ? \"CommentBlock\" : \"CommentLine\",\n        value: text,\n        start: start,\n        end: end,\n        loc: new SourceLocation(startLoc, endLoc)\n      };\n      if (this.options.tokens) this.pushToken(comment);\n      this.state.comments.push(comment);\n      this.addComment(comment);\n    }\n  }, {\n    key: \"skipBlockComment\",\n    value: function skipBlockComment() {\n      var startLoc = this.state.curPosition();\n      var start = this.state.pos;\n      var end = this.input.indexOf(\"*/\", this.state.pos + 2);\n      if (end === -1) throw this.raise(start, ErrorMessages.UnterminatedComment);\n      this.state.pos = end + 2;\n      lineBreakG.lastIndex = start;\n      var match;\n\n      while ((match = lineBreakG.exec(this.input)) && match.index < this.state.pos) {\n        ++this.state.curLine;\n        this.state.lineStart = match.index + match[0].length;\n      }\n\n      if (this.isLookahead) return;\n      this.pushComment(true, this.input.slice(start + 2, end), start, this.state.pos, startLoc, this.state.curPosition());\n    }\n  }, {\n    key: \"skipLineComment\",\n    value: function skipLineComment(startSkip) {\n      var start = this.state.pos;\n      var startLoc = this.state.curPosition();\n      var ch = this.input.charCodeAt(this.state.pos += startSkip);\n\n      if (this.state.pos < this.length) {\n        while (!isNewLine(ch) && ++this.state.pos < this.length) {\n          ch = this.input.charCodeAt(this.state.pos);\n        }\n      }\n\n      if (this.isLookahead) return;\n      this.pushComment(false, this.input.slice(start + startSkip, this.state.pos), start, this.state.pos, startLoc, this.state.curPosition());\n    }\n  }, {\n    key: \"skipSpace\",\n    value: function skipSpace() {\n      loop: while (this.state.pos < this.length) {\n        var ch = this.input.charCodeAt(this.state.pos);\n\n        switch (ch) {\n          case 32:\n          case 160:\n          case 9:\n            ++this.state.pos;\n            break;\n\n          case 13:\n            if (this.input.charCodeAt(this.state.pos + 1) === 10) {\n              ++this.state.pos;\n            }\n\n          case 10:\n          case 8232:\n          case 8233:\n            ++this.state.pos;\n            ++this.state.curLine;\n            this.state.lineStart = this.state.pos;\n            break;\n\n          case 47:\n            switch (this.input.charCodeAt(this.state.pos + 1)) {\n              case 42:\n                this.skipBlockComment();\n                break;\n\n              case 47:\n                this.skipLineComment(2);\n                break;\n\n              default:\n                break loop;\n            }\n\n            break;\n\n          default:\n            if (isWhitespace(ch)) {\n              ++this.state.pos;\n            } else {\n              break loop;\n            }\n\n        }\n      }\n    }\n  }, {\n    key: \"finishToken\",\n    value: function finishToken(type, val) {\n      this.state.end = this.state.pos;\n      this.state.endLoc = this.state.curPosition();\n      var prevType = this.state.type;\n      this.state.type = type;\n      this.state.value = val;\n      if (!this.isLookahead) this.updateContext(prevType);\n    }\n  }, {\n    key: \"readToken_numberSign\",\n    value: function readToken_numberSign() {\n      if (this.state.pos === 0 && this.readToken_interpreter()) {\n        return;\n      }\n\n      var nextPos = this.state.pos + 1;\n      var next = this.input.charCodeAt(nextPos);\n\n      if (next >= 48 && next <= 57) {\n        throw this.raise(this.state.pos, ErrorMessages.UnexpectedDigitAfterHash);\n      }\n\n      if (next === 123 || next === 91 && this.hasPlugin(\"recordAndTuple\")) {\n        this.expectPlugin(\"recordAndTuple\");\n\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"hash\") {\n          throw this.raise(this.state.pos, next === 123 ? ErrorMessages.RecordExpressionHashIncorrectStartSyntaxType : ErrorMessages.TupleExpressionHashIncorrectStartSyntaxType);\n        }\n\n        if (next === 123) {\n          this.finishToken(types.braceHashL);\n        } else {\n          this.finishToken(types.bracketHashL);\n        }\n\n        this.state.pos += 2;\n      } else {\n        this.finishOp(types.hash, 1);\n      }\n    }\n  }, {\n    key: \"readToken_dot\",\n    value: function readToken_dot() {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n\n      if (next >= 48 && next <= 57) {\n        this.readNumber(true);\n        return;\n      }\n\n      if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {\n        this.state.pos += 3;\n        this.finishToken(types.ellipsis);\n      } else {\n        ++this.state.pos;\n        this.finishToken(types.dot);\n      }\n    }\n  }, {\n    key: \"readToken_slash\",\n    value: function readToken_slash() {\n      if (this.state.exprAllowed && !this.state.inType) {\n        ++this.state.pos;\n        this.readRegexp();\n        return;\n      }\n\n      var next = this.input.charCodeAt(this.state.pos + 1);\n\n      if (next === 61) {\n        this.finishOp(types.assign, 2);\n      } else {\n        this.finishOp(types.slash, 1);\n      }\n    }\n  }, {\n    key: \"readToken_interpreter\",\n    value: function readToken_interpreter() {\n      if (this.state.pos !== 0 || this.length < 2) return false;\n      var ch = this.input.charCodeAt(this.state.pos + 1);\n      if (ch !== 33) return false;\n      var start = this.state.pos;\n      this.state.pos += 1;\n\n      while (!isNewLine(ch) && ++this.state.pos < this.length) {\n        ch = this.input.charCodeAt(this.state.pos);\n      }\n\n      var value = this.input.slice(start + 2, this.state.pos);\n      this.finishToken(types.interpreterDirective, value);\n      return true;\n    }\n  }, {\n    key: \"readToken_mult_modulo\",\n    value: function readToken_mult_modulo(code) {\n      var type = code === 42 ? types.star : types.modulo;\n      var width = 1;\n      var next = this.input.charCodeAt(this.state.pos + 1);\n      var exprAllowed = this.state.exprAllowed;\n\n      if (code === 42 && next === 42) {\n        width++;\n        next = this.input.charCodeAt(this.state.pos + 2);\n        type = types.exponent;\n      }\n\n      if (next === 61 && !exprAllowed) {\n        width++;\n        type = types.assign;\n      }\n\n      this.finishOp(type, width);\n    }\n  }, {\n    key: \"readToken_pipe_amp\",\n    value: function readToken_pipe_amp(code) {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n\n      if (next === code) {\n        if (this.input.charCodeAt(this.state.pos + 2) === 61) {\n          this.finishOp(types.assign, 3);\n        } else {\n          this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2);\n        }\n\n        return;\n      }\n\n      if (code === 124) {\n        if (next === 62) {\n          this.finishOp(types.pipeline, 2);\n          return;\n        }\n\n        if (this.hasPlugin(\"recordAndTuple\") && next === 125) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(this.state.pos, ErrorMessages.RecordExpressionBarIncorrectEndSyntaxType);\n          }\n\n          this.finishOp(types.braceBarR, 2);\n          return;\n        }\n\n        if (this.hasPlugin(\"recordAndTuple\") && next === 93) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(this.state.pos, ErrorMessages.TupleExpressionBarIncorrectEndSyntaxType);\n          }\n\n          this.finishOp(types.bracketBarR, 2);\n          return;\n        }\n      }\n\n      if (next === 61) {\n        this.finishOp(types.assign, 2);\n        return;\n      }\n\n      this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1);\n    }\n  }, {\n    key: \"readToken_caret\",\n    value: function readToken_caret() {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n\n      if (next === 61) {\n        this.finishOp(types.assign, 2);\n      } else {\n        this.finishOp(types.bitwiseXOR, 1);\n      }\n    }\n  }, {\n    key: \"readToken_plus_min\",\n    value: function readToken_plus_min(code) {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n\n      if (next === code) {\n        if (next === 45 && !this.inModule && this.input.charCodeAt(this.state.pos + 2) === 62 && (this.state.lastTokEnd === 0 || this.hasPrecedingLineBreak())) {\n          this.skipLineComment(3);\n          this.skipSpace();\n          this.nextToken();\n          return;\n        }\n\n        this.finishOp(types.incDec, 2);\n        return;\n      }\n\n      if (next === 61) {\n        this.finishOp(types.assign, 2);\n      } else {\n        this.finishOp(types.plusMin, 1);\n      }\n    }\n  }, {\n    key: \"readToken_lt_gt\",\n    value: function readToken_lt_gt(code) {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n      var size = 1;\n\n      if (next === code) {\n        size = code === 62 && this.input.charCodeAt(this.state.pos + 2) === 62 ? 3 : 2;\n\n        if (this.input.charCodeAt(this.state.pos + size) === 61) {\n          this.finishOp(types.assign, size + 1);\n          return;\n        }\n\n        this.finishOp(types.bitShift, size);\n        return;\n      }\n\n      if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.state.pos + 2) === 45 && this.input.charCodeAt(this.state.pos + 3) === 45) {\n        this.skipLineComment(4);\n        this.skipSpace();\n        this.nextToken();\n        return;\n      }\n\n      if (next === 61) {\n        size = 2;\n      }\n\n      this.finishOp(types.relational, size);\n    }\n  }, {\n    key: \"readToken_eq_excl\",\n    value: function readToken_eq_excl(code) {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n\n      if (next === 61) {\n        this.finishOp(types.equality, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);\n        return;\n      }\n\n      if (code === 61 && next === 62) {\n        this.state.pos += 2;\n        this.finishToken(types.arrow);\n        return;\n      }\n\n      this.finishOp(code === 61 ? types.eq : types.bang, 1);\n    }\n  }, {\n    key: \"readToken_question\",\n    value: function readToken_question() {\n      var next = this.input.charCodeAt(this.state.pos + 1);\n      var next2 = this.input.charCodeAt(this.state.pos + 2);\n\n      if (next === 63) {\n        if (next2 === 61) {\n          this.finishOp(types.assign, 3);\n        } else {\n          this.finishOp(types.nullishCoalescing, 2);\n        }\n      } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {\n        this.state.pos += 2;\n        this.finishToken(types.questionDot);\n      } else {\n        ++this.state.pos;\n        this.finishToken(types.question);\n      }\n    }\n  }, {\n    key: \"getTokenFromCode\",\n    value: function getTokenFromCode(code) {\n      switch (code) {\n        case 46:\n          this.readToken_dot();\n          return;\n\n        case 40:\n          ++this.state.pos;\n          this.finishToken(types.parenL);\n          return;\n\n        case 41:\n          ++this.state.pos;\n          this.finishToken(types.parenR);\n          return;\n\n        case 59:\n          ++this.state.pos;\n          this.finishToken(types.semi);\n          return;\n\n        case 44:\n          ++this.state.pos;\n          this.finishToken(types.comma);\n          return;\n\n        case 91:\n          if (this.hasPlugin(\"recordAndTuple\") && this.input.charCodeAt(this.state.pos + 1) === 124) {\n            if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n              throw this.raise(this.state.pos, ErrorMessages.TupleExpressionBarIncorrectStartSyntaxType);\n            }\n\n            this.finishToken(types.bracketBarL);\n            this.state.pos += 2;\n          } else {\n            ++this.state.pos;\n            this.finishToken(types.bracketL);\n          }\n\n          return;\n\n        case 93:\n          ++this.state.pos;\n          this.finishToken(types.bracketR);\n          return;\n\n        case 123:\n          if (this.hasPlugin(\"recordAndTuple\") && this.input.charCodeAt(this.state.pos + 1) === 124) {\n            if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n              throw this.raise(this.state.pos, ErrorMessages.RecordExpressionBarIncorrectStartSyntaxType);\n            }\n\n            this.finishToken(types.braceBarL);\n            this.state.pos += 2;\n          } else {\n            ++this.state.pos;\n            this.finishToken(types.braceL);\n          }\n\n          return;\n\n        case 125:\n          ++this.state.pos;\n          this.finishToken(types.braceR);\n          return;\n\n        case 58:\n          if (this.hasPlugin(\"functionBind\") && this.input.charCodeAt(this.state.pos + 1) === 58) {\n            this.finishOp(types.doubleColon, 2);\n          } else {\n            ++this.state.pos;\n            this.finishToken(types.colon);\n          }\n\n          return;\n\n        case 63:\n          this.readToken_question();\n          return;\n\n        case 96:\n          ++this.state.pos;\n          this.finishToken(types.backQuote);\n          return;\n\n        case 48:\n          {\n            var next = this.input.charCodeAt(this.state.pos + 1);\n\n            if (next === 120 || next === 88) {\n              this.readRadixNumber(16);\n              return;\n            }\n\n            if (next === 111 || next === 79) {\n              this.readRadixNumber(8);\n              return;\n            }\n\n            if (next === 98 || next === 66) {\n              this.readRadixNumber(2);\n              return;\n            }\n          }\n\n        case 49:\n        case 50:\n        case 51:\n        case 52:\n        case 53:\n        case 54:\n        case 55:\n        case 56:\n        case 57:\n          this.readNumber(false);\n          return;\n\n        case 34:\n        case 39:\n          this.readString(code);\n          return;\n\n        case 47:\n          this.readToken_slash();\n          return;\n\n        case 37:\n        case 42:\n          this.readToken_mult_modulo(code);\n          return;\n\n        case 124:\n        case 38:\n          this.readToken_pipe_amp(code);\n          return;\n\n        case 94:\n          this.readToken_caret();\n          return;\n\n        case 43:\n        case 45:\n          this.readToken_plus_min(code);\n          return;\n\n        case 60:\n        case 62:\n          this.readToken_lt_gt(code);\n          return;\n\n        case 61:\n        case 33:\n          this.readToken_eq_excl(code);\n          return;\n\n        case 126:\n          this.finishOp(types.tilde, 1);\n          return;\n\n        case 64:\n          ++this.state.pos;\n          this.finishToken(types.at);\n          return;\n\n        case 35:\n          this.readToken_numberSign();\n          return;\n\n        case 92:\n          this.readWord();\n          return;\n\n        default:\n          if (isIdentifierStart(code)) {\n            this.readWord();\n            return;\n          }\n\n      }\n\n      throw this.raise(this.state.pos, ErrorMessages.InvalidOrUnexpectedToken, String.fromCodePoint(code));\n    }\n  }, {\n    key: \"finishOp\",\n    value: function finishOp(type, size) {\n      var str = this.input.slice(this.state.pos, this.state.pos + size);\n      this.state.pos += size;\n      this.finishToken(type, str);\n    }\n  }, {\n    key: \"readRegexp\",\n    value: function readRegexp() {\n      var start = this.state.pos;\n      var escaped, inClass;\n\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(start, ErrorMessages.UnterminatedRegExp);\n        }\n\n        var ch = this.input.charAt(this.state.pos);\n\n        if (lineBreak.test(ch)) {\n          throw this.raise(start, ErrorMessages.UnterminatedRegExp);\n        }\n\n        if (escaped) {\n          escaped = false;\n        } else {\n          if (ch === \"[\") {\n            inClass = true;\n          } else if (ch === \"]\" && inClass) {\n            inClass = false;\n          } else if (ch === \"/\" && !inClass) {\n            break;\n          }\n\n          escaped = ch === \"\\\\\";\n        }\n\n        ++this.state.pos;\n      }\n\n      var content = this.input.slice(start, this.state.pos);\n      ++this.state.pos;\n      var mods = \"\";\n\n      while (this.state.pos < this.length) {\n        var char = this.input[this.state.pos];\n        var charCode = this.input.codePointAt(this.state.pos);\n\n        if (VALID_REGEX_FLAGS.has(char)) {\n          if (mods.indexOf(char) > -1) {\n            this.raise(this.state.pos + 1, ErrorMessages.DuplicateRegExpFlags);\n          }\n        } else if (isIdentifierChar(charCode) || charCode === 92) {\n          this.raise(this.state.pos + 1, ErrorMessages.MalformedRegExpFlags);\n        } else {\n          break;\n        }\n\n        ++this.state.pos;\n        mods += char;\n      }\n\n      this.finishToken(types.regexp, {\n        pattern: content,\n        flags: mods\n      });\n    }\n  }, {\n    key: \"readInt\",\n    value: function readInt(radix, len, forceLen) {\n      var allowNumSeparator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;\n      var start = this.state.pos;\n      var forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;\n      var allowedSiblings = radix === 16 ? allowedNumericSeparatorSiblings.hex : radix === 10 ? allowedNumericSeparatorSiblings.dec : radix === 8 ? allowedNumericSeparatorSiblings.oct : allowedNumericSeparatorSiblings.bin;\n      var invalid = false;\n      var total = 0;\n\n      for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n        var code = this.input.charCodeAt(this.state.pos);\n        var val = void 0;\n\n        if (code === 95) {\n          var prev = this.input.charCodeAt(this.state.pos - 1);\n          var next = this.input.charCodeAt(this.state.pos + 1);\n\n          if (allowedSiblings.indexOf(next) === -1) {\n            this.raise(this.state.pos, ErrorMessages.UnexpectedNumericSeparator);\n          } else if (forbiddenSiblings.indexOf(prev) > -1 || forbiddenSiblings.indexOf(next) > -1 || Number.isNaN(next)) {\n            this.raise(this.state.pos, ErrorMessages.UnexpectedNumericSeparator);\n          }\n\n          if (!allowNumSeparator) {\n            this.raise(this.state.pos, ErrorMessages.NumericSeparatorInEscapeSequence);\n          }\n\n          ++this.state.pos;\n          continue;\n        }\n\n        if (code >= 97) {\n          val = code - 97 + 10;\n        } else if (code >= 65) {\n          val = code - 65 + 10;\n        } else if (_isDigit(code)) {\n          val = code - 48;\n        } else {\n          val = Infinity;\n        }\n\n        if (val >= radix) {\n          if (this.options.errorRecovery && val <= 9) {\n            val = 0;\n            this.raise(this.state.start + i + 2, ErrorMessages.InvalidDigit, radix);\n          } else if (forceLen) {\n            val = 0;\n            invalid = true;\n          } else {\n            break;\n          }\n        }\n\n        ++this.state.pos;\n        total = total * radix + val;\n      }\n\n      if (this.state.pos === start || len != null && this.state.pos - start !== len || invalid) {\n        return null;\n      }\n\n      return total;\n    }\n  }, {\n    key: \"readRadixNumber\",\n    value: function readRadixNumber(radix) {\n      var start = this.state.pos;\n      var isBigInt = false;\n      this.state.pos += 2;\n      var val = this.readInt(radix);\n\n      if (val == null) {\n        this.raise(this.state.start + 2, ErrorMessages.InvalidDigit, radix);\n      }\n\n      var next = this.input.charCodeAt(this.state.pos);\n\n      if (next === 110) {\n        ++this.state.pos;\n        isBigInt = true;\n      } else if (next === 109) {\n        throw this.raise(start, ErrorMessages.InvalidDecimal);\n      }\n\n      if (isIdentifierStart(this.input.codePointAt(this.state.pos))) {\n        throw this.raise(this.state.pos, ErrorMessages.NumberIdentifier);\n      }\n\n      if (isBigInt) {\n        var str = this.input.slice(start, this.state.pos).replace(/[_n]/g, \"\");\n        this.finishToken(types.bigint, str);\n        return;\n      }\n\n      this.finishToken(types.num, val);\n    }\n  }, {\n    key: \"readNumber\",\n    value: function readNumber(startsWithDot) {\n      var start = this.state.pos;\n      var isFloat = false;\n      var isBigInt = false;\n      var isDecimal = false;\n      var hasExponent = false;\n      var isOctal = false;\n\n      if (!startsWithDot && this.readInt(10) === null) {\n        this.raise(start, ErrorMessages.InvalidNumber);\n      }\n\n      var hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;\n\n      if (hasLeadingZero) {\n        var integer = this.input.slice(start, this.state.pos);\n\n        if (this.state.strict) {\n          this.raise(start, ErrorMessages.StrictOctalLiteral);\n        } else {\n          var underscorePos = integer.indexOf(\"_\");\n\n          if (underscorePos > 0) {\n            this.raise(underscorePos + start, ErrorMessages.ZeroDigitNumericSeparator);\n          }\n        }\n\n        isOctal = hasLeadingZero && !/[89]/.test(integer);\n      }\n\n      var next = this.input.charCodeAt(this.state.pos);\n\n      if (next === 46 && !isOctal) {\n        ++this.state.pos;\n        this.readInt(10);\n        isFloat = true;\n        next = this.input.charCodeAt(this.state.pos);\n      }\n\n      if ((next === 69 || next === 101) && !isOctal) {\n        next = this.input.charCodeAt(++this.state.pos);\n\n        if (next === 43 || next === 45) {\n          ++this.state.pos;\n        }\n\n        if (this.readInt(10) === null) this.raise(start, ErrorMessages.InvalidNumber);\n        isFloat = true;\n        hasExponent = true;\n        next = this.input.charCodeAt(this.state.pos);\n      }\n\n      if (next === 110) {\n        if (isFloat || hasLeadingZero) {\n          this.raise(start, ErrorMessages.InvalidBigIntLiteral);\n        }\n\n        ++this.state.pos;\n        isBigInt = true;\n      }\n\n      if (next === 109) {\n        this.expectPlugin(\"decimal\", this.state.pos);\n\n        if (hasExponent || hasLeadingZero) {\n          this.raise(start, ErrorMessages.InvalidDecimal);\n        }\n\n        ++this.state.pos;\n        isDecimal = true;\n      }\n\n      if (isIdentifierStart(this.input.codePointAt(this.state.pos))) {\n        throw this.raise(this.state.pos, ErrorMessages.NumberIdentifier);\n      }\n\n      var str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, \"\");\n\n      if (isBigInt) {\n        this.finishToken(types.bigint, str);\n        return;\n      }\n\n      if (isDecimal) {\n        this.finishToken(types.decimal, str);\n        return;\n      }\n\n      var val = isOctal ? parseInt(str, 8) : parseFloat(str);\n      this.finishToken(types.num, val);\n    }\n  }, {\n    key: \"readCodePoint\",\n    value: function readCodePoint(throwOnInvalid) {\n      var ch = this.input.charCodeAt(this.state.pos);\n      var code;\n\n      if (ch === 123) {\n        var codePos = ++this.state.pos;\n        code = this.readHexChar(this.input.indexOf(\"}\", this.state.pos) - this.state.pos, true, throwOnInvalid);\n        ++this.state.pos;\n\n        if (code !== null && code > 0x10ffff) {\n          if (throwOnInvalid) {\n            this.raise(codePos, ErrorMessages.InvalidCodePoint);\n          } else {\n            return null;\n          }\n        }\n      } else {\n        code = this.readHexChar(4, false, throwOnInvalid);\n      }\n\n      return code;\n    }\n  }, {\n    key: \"readString\",\n    value: function readString(quote) {\n      var out = \"\",\n          chunkStart = ++this.state.pos;\n\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(this.state.start, ErrorMessages.UnterminatedString);\n        }\n\n        var ch = this.input.charCodeAt(this.state.pos);\n        if (ch === quote) break;\n\n        if (ch === 92) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          out += this.readEscapedChar(false);\n          chunkStart = this.state.pos;\n        } else if (ch === 8232 || ch === 8233) {\n          ++this.state.pos;\n          ++this.state.curLine;\n          this.state.lineStart = this.state.pos;\n        } else if (isNewLine(ch)) {\n          throw this.raise(this.state.start, ErrorMessages.UnterminatedString);\n        } else {\n          ++this.state.pos;\n        }\n      }\n\n      out += this.input.slice(chunkStart, this.state.pos++);\n      this.finishToken(types.string, out);\n    }\n  }, {\n    key: \"readTmplToken\",\n    value: function readTmplToken() {\n      var out = \"\",\n          chunkStart = this.state.pos,\n          containsInvalid = false;\n\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(this.state.start, ErrorMessages.UnterminatedTemplate);\n        }\n\n        var ch = this.input.charCodeAt(this.state.pos);\n\n        if (ch === 96 || ch === 36 && this.input.charCodeAt(this.state.pos + 1) === 123) {\n          if (this.state.pos === this.state.start && this.match(types.template)) {\n            if (ch === 36) {\n              this.state.pos += 2;\n              this.finishToken(types.dollarBraceL);\n              return;\n            } else {\n              ++this.state.pos;\n              this.finishToken(types.backQuote);\n              return;\n            }\n          }\n\n          out += this.input.slice(chunkStart, this.state.pos);\n          this.finishToken(types.template, containsInvalid ? null : out);\n          return;\n        }\n\n        if (ch === 92) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          var escaped = this.readEscapedChar(true);\n\n          if (escaped === null) {\n            containsInvalid = true;\n          } else {\n            out += escaped;\n          }\n\n          chunkStart = this.state.pos;\n        } else if (isNewLine(ch)) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          ++this.state.pos;\n\n          switch (ch) {\n            case 13:\n              if (this.input.charCodeAt(this.state.pos) === 10) {\n                ++this.state.pos;\n              }\n\n            case 10:\n              out += \"\\n\";\n              break;\n\n            default:\n              out += String.fromCharCode(ch);\n              break;\n          }\n\n          ++this.state.curLine;\n          this.state.lineStart = this.state.pos;\n          chunkStart = this.state.pos;\n        } else {\n          ++this.state.pos;\n        }\n      }\n    }\n  }, {\n    key: \"readEscapedChar\",\n    value: function readEscapedChar(inTemplate) {\n      var throwOnInvalid = !inTemplate;\n      var ch = this.input.charCodeAt(++this.state.pos);\n      ++this.state.pos;\n\n      switch (ch) {\n        case 110:\n          return \"\\n\";\n\n        case 114:\n          return \"\\r\";\n\n        case 120:\n          {\n            var code = this.readHexChar(2, false, throwOnInvalid);\n            return code === null ? null : String.fromCharCode(code);\n          }\n\n        case 117:\n          {\n            var _code = this.readCodePoint(throwOnInvalid);\n\n            return _code === null ? null : String.fromCodePoint(_code);\n          }\n\n        case 116:\n          return \"\\t\";\n\n        case 98:\n          return \"\\b\";\n\n        case 118:\n          return \"\\x0B\";\n\n        case 102:\n          return \"\\f\";\n\n        case 13:\n          if (this.input.charCodeAt(this.state.pos) === 10) {\n            ++this.state.pos;\n          }\n\n        case 10:\n          this.state.lineStart = this.state.pos;\n          ++this.state.curLine;\n\n        case 8232:\n        case 8233:\n          return \"\";\n\n        case 56:\n        case 57:\n          if (inTemplate) {\n            return null;\n          } else if (this.state.strict) {\n            this.raise(this.state.pos - 1, ErrorMessages.StrictNumericEscape);\n          }\n\n        default:\n          if (ch >= 48 && ch <= 55) {\n            var codePos = this.state.pos - 1;\n            var match = this.input.substr(this.state.pos - 1, 3).match(/^[0-7]+/);\n            var octalStr = match[0];\n            var octal = parseInt(octalStr, 8);\n\n            if (octal > 255) {\n              octalStr = octalStr.slice(0, -1);\n              octal = parseInt(octalStr, 8);\n            }\n\n            this.state.pos += octalStr.length - 1;\n            var next = this.input.charCodeAt(this.state.pos);\n\n            if (octalStr !== \"0\" || next === 56 || next === 57) {\n              if (inTemplate) {\n                return null;\n              } else if (this.state.strict) {\n                this.raise(codePos, ErrorMessages.StrictNumericEscape);\n              } else {\n                this.state.octalPositions.push(codePos);\n              }\n            }\n\n            return String.fromCharCode(octal);\n          }\n\n          return String.fromCharCode(ch);\n      }\n    }\n  }, {\n    key: \"readHexChar\",\n    value: function readHexChar(len, forceLen, throwOnInvalid) {\n      var codePos = this.state.pos;\n      var n = this.readInt(16, len, forceLen, false);\n\n      if (n === null) {\n        if (throwOnInvalid) {\n          this.raise(codePos, ErrorMessages.InvalidEscapeSequence);\n        } else {\n          this.state.pos = codePos - 1;\n        }\n      }\n\n      return n;\n    }\n  }, {\n    key: \"readWord1\",\n    value: function readWord1() {\n      var word = \"\";\n      this.state.containsEsc = false;\n      var start = this.state.pos;\n      var chunkStart = this.state.pos;\n\n      while (this.state.pos < this.length) {\n        var ch = this.input.codePointAt(this.state.pos);\n\n        if (isIdentifierChar(ch)) {\n          this.state.pos += ch <= 0xffff ? 1 : 2;\n        } else if (this.state.isIterator && ch === 64) {\n          ++this.state.pos;\n        } else if (ch === 92) {\n          this.state.containsEsc = true;\n          word += this.input.slice(chunkStart, this.state.pos);\n          var escStart = this.state.pos;\n          var identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;\n\n          if (this.input.charCodeAt(++this.state.pos) !== 117) {\n            this.raise(this.state.pos, ErrorMessages.MissingUnicodeEscape);\n            continue;\n          }\n\n          ++this.state.pos;\n          var esc = this.readCodePoint(true);\n\n          if (esc !== null) {\n            if (!identifierCheck(esc)) {\n              this.raise(escStart, ErrorMessages.EscapedCharNotAnIdentifier);\n            }\n\n            word += String.fromCodePoint(esc);\n          }\n\n          chunkStart = this.state.pos;\n        } else {\n          break;\n        }\n      }\n\n      return word + this.input.slice(chunkStart, this.state.pos);\n    }\n  }, {\n    key: \"isIterator\",\n    value: function isIterator(word) {\n      return word === \"@@iterator\" || word === \"@@asyncIterator\";\n    }\n  }, {\n    key: \"readWord\",\n    value: function readWord() {\n      var word = this.readWord1();\n      var type = keywords.get(word) || types.name;\n\n      if (this.state.isIterator && (!this.isIterator(word) || !this.state.inType)) {\n        this.raise(this.state.pos, ErrorMessages.InvalidIdentifier, word);\n      }\n\n      this.finishToken(type, word);\n    }\n  }, {\n    key: \"checkKeywordEscapes\",\n    value: function checkKeywordEscapes() {\n      var kw = this.state.type.keyword;\n\n      if (kw && this.state.containsEsc) {\n        this.raise(this.state.start, ErrorMessages.InvalidEscapedReservedWord, kw);\n      }\n    }\n  }, {\n    key: \"braceIsBlock\",\n    value: function braceIsBlock(prevType) {\n      var parent = this.curContext();\n\n      if (parent === types$1.functionExpression || parent === types$1.functionStatement) {\n        return true;\n      }\n\n      if (prevType === types.colon && (parent === types$1.braceStatement || parent === types$1.braceExpression)) {\n        return !parent.isExpr;\n      }\n\n      if (prevType === types._return || prevType === types.name && this.state.exprAllowed) {\n        return this.hasPrecedingLineBreak();\n      }\n\n      if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow) {\n        return true;\n      }\n\n      if (prevType === types.braceL) {\n        return parent === types$1.braceStatement;\n      }\n\n      if (prevType === types._var || prevType === types._const || prevType === types.name) {\n        return false;\n      }\n\n      if (prevType === types.relational) {\n        return true;\n      }\n\n      return !this.state.exprAllowed;\n    }\n  }, {\n    key: \"updateContext\",\n    value: function updateContext(prevType) {\n      var type = this.state.type;\n      var update;\n\n      if (type.keyword && (prevType === types.dot || prevType === types.questionDot)) {\n        this.state.exprAllowed = false;\n      } else if (update = type.updateContext) {\n        update.call(this, prevType);\n      } else {\n        this.state.exprAllowed = type.beforeExpr;\n      }\n    }\n  }]);\n\n  return Tokenizer;\n}(ParserError);\n\nvar UtilParser = /*#__PURE__*/function (_Tokenizer) {\n  _inherits(UtilParser, _Tokenizer);\n\n  var _super12 = _createSuper(UtilParser);\n\n  function UtilParser() {\n    _classCallCheck(this, UtilParser);\n\n    return _super12.apply(this, arguments);\n  }\n\n  _createClass(UtilParser, [{\n    key: \"addExtra\",\n    value: function addExtra(node, key, val) {\n      if (!node) return;\n      var extra = node.extra = node.extra || {};\n      extra[key] = val;\n    }\n  }, {\n    key: \"isRelational\",\n    value: function isRelational(op) {\n      return this.match(types.relational) && this.state.value === op;\n    }\n  }, {\n    key: \"expectRelational\",\n    value: function expectRelational(op) {\n      if (this.isRelational(op)) {\n        this.next();\n      } else {\n        this.unexpected(null, types.relational);\n      }\n    }\n  }, {\n    key: \"isContextual\",\n    value: function isContextual(name) {\n      return this.match(types.name) && this.state.value === name && !this.state.containsEsc;\n    }\n  }, {\n    key: \"isUnparsedContextual\",\n    value: function isUnparsedContextual(nameStart, name) {\n      var nameEnd = nameStart + name.length;\n      return this.input.slice(nameStart, nameEnd) === name && (nameEnd === this.input.length || !isIdentifierChar(this.input.charCodeAt(nameEnd)));\n    }\n  }, {\n    key: \"isLookaheadContextual\",\n    value: function isLookaheadContextual(name) {\n      var next = this.nextTokenStart();\n      return this.isUnparsedContextual(next, name);\n    }\n  }, {\n    key: \"eatContextual\",\n    value: function eatContextual(name) {\n      return this.isContextual(name) && this.eat(types.name);\n    }\n  }, {\n    key: \"expectContextual\",\n    value: function expectContextual(name, message) {\n      if (!this.eatContextual(name)) this.unexpected(null, message);\n    }\n  }, {\n    key: \"canInsertSemicolon\",\n    value: function canInsertSemicolon() {\n      return this.match(types.eof) || this.match(types.braceR) || this.hasPrecedingLineBreak();\n    }\n  }, {\n    key: \"hasPrecedingLineBreak\",\n    value: function hasPrecedingLineBreak() {\n      return lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start));\n    }\n  }, {\n    key: \"isLineTerminator\",\n    value: function isLineTerminator() {\n      return this.eat(types.semi) || this.canInsertSemicolon();\n    }\n  }, {\n    key: \"semicolon\",\n    value: function semicolon() {\n      if (!this.isLineTerminator()) this.unexpected(null, types.semi);\n    }\n  }, {\n    key: \"expect\",\n    value: function expect(type, pos) {\n      this.eat(type) || this.unexpected(pos, type);\n    }\n  }, {\n    key: \"assertNoSpace\",\n    value: function assertNoSpace() {\n      var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : \"Unexpected space.\";\n\n      if (this.state.start > this.state.lastTokEnd) {\n        this.raise(this.state.lastTokEnd, message);\n      }\n    }\n  }, {\n    key: \"unexpected\",\n    value: function unexpected(pos) {\n      var messageOrType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"Unexpected token\";\n\n      if (typeof messageOrType !== \"string\") {\n        messageOrType = \"Unexpected token, expected \\\"\".concat(messageOrType.label, \"\\\"\");\n      }\n\n      throw this.raise(pos != null ? pos : this.state.start, messageOrType);\n    }\n  }, {\n    key: \"expectPlugin\",\n    value: function expectPlugin(name, pos) {\n      if (!this.hasPlugin(name)) {\n        throw this.raiseWithData(pos != null ? pos : this.state.start, {\n          missingPlugin: [name]\n        }, \"This experimental syntax requires enabling the parser plugin: '\".concat(name, \"'\"));\n      }\n\n      return true;\n    }\n  }, {\n    key: \"expectOnePlugin\",\n    value: function expectOnePlugin(names, pos) {\n      var _this35 = this;\n\n      if (!names.some(function (n) {\n        return _this35.hasPlugin(n);\n      })) {\n        throw this.raiseWithData(pos != null ? pos : this.state.start, {\n          missingPlugin: names\n        }, \"This experimental syntax requires enabling one of the following parser plugin(s): '\".concat(names.join(\", \"), \"'\"));\n      }\n    }\n  }, {\n    key: \"checkYieldAwaitInDefaultParams\",\n    value: function checkYieldAwaitInDefaultParams() {\n      if (this.state.yieldPos !== -1 && (this.state.awaitPos === -1 || this.state.yieldPos < this.state.awaitPos)) {\n        this.raise(this.state.yieldPos, ErrorMessages.YieldBindingIdentifier);\n      }\n\n      if (this.state.awaitPos !== -1) {\n        this.raise(this.state.awaitPos, ErrorMessages.AwaitBindingIdentifier);\n      }\n    }\n  }, {\n    key: \"tryParse\",\n    value: function tryParse(fn) {\n      var oldState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.clone();\n      var abortSignal = {\n        node: null\n      };\n\n      try {\n        var node = fn(function () {\n          var node = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n          abortSignal.node = node;\n          throw abortSignal;\n        });\n\n        if (this.state.errors.length > oldState.errors.length) {\n          var failState = this.state;\n          this.state = oldState;\n          return {\n            node: node,\n            error: failState.errors[oldState.errors.length],\n            thrown: false,\n            aborted: false,\n            failState: failState\n          };\n        }\n\n        return {\n          node: node,\n          error: null,\n          thrown: false,\n          aborted: false,\n          failState: null\n        };\n      } catch (error) {\n        var _failState = this.state;\n        this.state = oldState;\n\n        if (error instanceof SyntaxError) {\n          return {\n            node: null,\n            error: error,\n            thrown: true,\n            aborted: false,\n            failState: _failState\n          };\n        }\n\n        if (error === abortSignal) {\n          return {\n            node: abortSignal.node,\n            error: null,\n            thrown: false,\n            aborted: true,\n            failState: _failState\n          };\n        }\n\n        throw error;\n      }\n    }\n  }, {\n    key: \"checkExpressionErrors\",\n    value: function checkExpressionErrors(refExpressionErrors, andThrow) {\n      if (!refExpressionErrors) return false;\n      var shorthandAssign = refExpressionErrors.shorthandAssign,\n          doubleProto = refExpressionErrors.doubleProto;\n      if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0;\n\n      if (shorthandAssign >= 0) {\n        this.unexpected(shorthandAssign);\n      }\n\n      if (doubleProto >= 0) {\n        this.raise(doubleProto, ErrorMessages.DuplicateProto);\n      }\n    }\n  }, {\n    key: \"isLiteralPropertyName\",\n    value: function isLiteralPropertyName() {\n      return this.match(types.name) || !!this.state.type.keyword || this.match(types.string) || this.match(types.num) || this.match(types.bigint) || this.match(types.decimal);\n    }\n  }]);\n\n  return UtilParser;\n}(Tokenizer);\n\nvar ExpressionErrors = function ExpressionErrors() {\n  _classCallCheck(this, ExpressionErrors);\n\n  this.shorthandAssign = -1;\n  this.doubleProto = -1;\n};\n\nvar Node = /*#__PURE__*/function () {\n  function Node(parser, pos, loc) {\n    _classCallCheck(this, Node);\n\n    this.type = \"\";\n    this.start = pos;\n    this.end = 0;\n    this.loc = new SourceLocation(loc);\n    if (parser == null ? void 0 : parser.options.ranges) this.range = [pos, 0];\n    if (parser == null ? void 0 : parser.filename) this.loc.filename = parser.filename;\n  }\n\n  _createClass(Node, [{\n    key: \"__clone\",\n    value: function __clone() {\n      var newNode = new Node();\n      var keys = Object.keys(this);\n\n      for (var i = 0, length = keys.length; i < length; i++) {\n        var key = keys[i];\n\n        if (key !== \"leadingComments\" && key !== \"trailingComments\" && key !== \"innerComments\") {\n          newNode[key] = this[key];\n        }\n      }\n\n      return newNode;\n    }\n  }]);\n\n  return Node;\n}();\n\nvar NodeUtils = /*#__PURE__*/function (_UtilParser) {\n  _inherits(NodeUtils, _UtilParser);\n\n  var _super13 = _createSuper(NodeUtils);\n\n  function NodeUtils() {\n    _classCallCheck(this, NodeUtils);\n\n    return _super13.apply(this, arguments);\n  }\n\n  _createClass(NodeUtils, [{\n    key: \"startNode\",\n    value: function startNode() {\n      return new Node(this, this.state.start, this.state.startLoc);\n    }\n  }, {\n    key: \"startNodeAt\",\n    value: function startNodeAt(pos, loc) {\n      return new Node(this, pos, loc);\n    }\n  }, {\n    key: \"startNodeAtNode\",\n    value: function startNodeAtNode(type) {\n      return this.startNodeAt(type.start, type.loc.start);\n    }\n  }, {\n    key: \"finishNode\",\n    value: function finishNode(node, type) {\n      return this.finishNodeAt(node, type, this.state.lastTokEnd, this.state.lastTokEndLoc);\n    }\n  }, {\n    key: \"finishNodeAt\",\n    value: function finishNodeAt(node, type, pos, loc) {\n      node.type = type;\n      node.end = pos;\n      node.loc.end = loc;\n      if (this.options.ranges) node.range[1] = pos;\n      this.processComment(node);\n      return node;\n    }\n  }, {\n    key: \"resetStartLocation\",\n    value: function resetStartLocation(node, start, startLoc) {\n      node.start = start;\n      node.loc.start = startLoc;\n      if (this.options.ranges) node.range[0] = start;\n    }\n  }, {\n    key: \"resetEndLocation\",\n    value: function resetEndLocation(node) {\n      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.lastTokEnd;\n      var endLoc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.state.lastTokEndLoc;\n      node.end = end;\n      node.loc.end = endLoc;\n      if (this.options.ranges) node.range[1] = end;\n    }\n  }, {\n    key: \"resetStartLocationFromNode\",\n    value: function resetStartLocationFromNode(node, locationNode) {\n      this.resetStartLocation(node, locationNode.start, locationNode.loc.start);\n    }\n  }]);\n\n  return NodeUtils;\n}(UtilParser);\n\nvar unwrapParenthesizedExpression = function unwrapParenthesizedExpression(node) {\n  return node.type === \"ParenthesizedExpression\" ? unwrapParenthesizedExpression(node.expression) : node;\n};\n\nvar LValParser = /*#__PURE__*/function (_NodeUtils) {\n  _inherits(LValParser, _NodeUtils);\n\n  var _super14 = _createSuper(LValParser);\n\n  function LValParser() {\n    _classCallCheck(this, LValParser);\n\n    return _super14.apply(this, arguments);\n  }\n\n  _createClass(LValParser, [{\n    key: \"toAssignable\",\n    value: function toAssignable(node) {\n      var _node$extra, _node$extra3;\n\n      var parenthesized = undefined;\n\n      if (node.type === \"ParenthesizedExpression\" || ((_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized)) {\n        parenthesized = unwrapParenthesizedExpression(node);\n\n        if (parenthesized.type !== \"Identifier\" && parenthesized.type !== \"MemberExpression\") {\n          this.raise(node.start, ErrorMessages.InvalidParenthesizedAssignment);\n        }\n      }\n\n      switch (node.type) {\n        case \"Identifier\":\n        case \"ObjectPattern\":\n        case \"ArrayPattern\":\n        case \"AssignmentPattern\":\n          break;\n\n        case \"ObjectExpression\":\n          node.type = \"ObjectPattern\";\n\n          for (var i = 0, length = node.properties.length, _last2 = length - 1; i < length; i++) {\n            var _node$extra2;\n\n            var prop = node.properties[i];\n            var isLast = i === _last2;\n            this.toAssignableObjectExpressionProp(prop, isLast);\n\n            if (isLast && prop.type === \"RestElement\" && ((_node$extra2 = node.extra) == null ? void 0 : _node$extra2.trailingComma)) {\n              this.raiseRestNotLast(node.extra.trailingComma);\n            }\n          }\n\n          break;\n\n        case \"ObjectProperty\":\n          this.toAssignable(node.value);\n          break;\n\n        case \"SpreadElement\":\n          {\n            this.checkToRestConversion(node);\n            node.type = \"RestElement\";\n            var arg = node.argument;\n            this.toAssignable(arg);\n            break;\n          }\n\n        case \"ArrayExpression\":\n          node.type = \"ArrayPattern\";\n          this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingComma);\n          break;\n\n        case \"AssignmentExpression\":\n          if (node.operator !== \"=\") {\n            this.raise(node.left.end, ErrorMessages.MissingEqInAssignment);\n          }\n\n          node.type = \"AssignmentPattern\";\n          delete node.operator;\n          this.toAssignable(node.left);\n          break;\n\n        case \"ParenthesizedExpression\":\n          this.toAssignable(parenthesized);\n          break;\n      }\n\n      return node;\n    }\n  }, {\n    key: \"toAssignableObjectExpressionProp\",\n    value: function toAssignableObjectExpressionProp(prop, isLast) {\n      if (prop.type === \"ObjectMethod\") {\n        var error = prop.kind === \"get\" || prop.kind === \"set\" ? ErrorMessages.PatternHasAccessor : ErrorMessages.PatternHasMethod;\n        this.raise(prop.key.start, error);\n      } else if (prop.type === \"SpreadElement\" && !isLast) {\n        this.raiseRestNotLast(prop.start);\n      } else {\n        this.toAssignable(prop);\n      }\n    }\n  }, {\n    key: \"toAssignableList\",\n    value: function toAssignableList(exprList, trailingCommaPos) {\n      var end = exprList.length;\n\n      if (end) {\n        var _last3 = exprList[end - 1];\n\n        if ((_last3 == null ? void 0 : _last3.type) === \"RestElement\") {\n          --end;\n        } else if ((_last3 == null ? void 0 : _last3.type) === \"SpreadElement\") {\n          _last3.type = \"RestElement\";\n          var arg = _last3.argument;\n          this.toAssignable(arg);\n\n          if (arg.type !== \"Identifier\" && arg.type !== \"MemberExpression\" && arg.type !== \"ArrayPattern\" && arg.type !== \"ObjectPattern\") {\n            this.unexpected(arg.start);\n          }\n\n          if (trailingCommaPos) {\n            this.raiseTrailingCommaAfterRest(trailingCommaPos);\n          }\n\n          --end;\n        }\n      }\n\n      for (var i = 0; i < end; i++) {\n        var elt = exprList[i];\n\n        if (elt) {\n          this.toAssignable(elt);\n\n          if (elt.type === \"RestElement\") {\n            this.raiseRestNotLast(elt.start);\n          }\n        }\n      }\n\n      return exprList;\n    }\n  }, {\n    key: \"toReferencedList\",\n    value: function toReferencedList(exprList, isParenthesizedExpr) {\n      return exprList;\n    }\n  }, {\n    key: \"toReferencedListDeep\",\n    value: function toReferencedListDeep(exprList, isParenthesizedExpr) {\n      this.toReferencedList(exprList, isParenthesizedExpr);\n\n      for (var _i = 0; _i < exprList.length; _i++) {\n        var expr = exprList[_i];\n\n        if ((expr == null ? void 0 : expr.type) === \"ArrayExpression\") {\n          this.toReferencedListDeep(expr.elements);\n        }\n      }\n    }\n  }, {\n    key: \"parseSpread\",\n    value: function parseSpread(refExpressionErrors, refNeedsArrowPos) {\n      var node = this.startNode();\n      this.next();\n      node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined, refNeedsArrowPos);\n      return this.finishNode(node, \"SpreadElement\");\n    }\n  }, {\n    key: \"parseRestBinding\",\n    value: function parseRestBinding() {\n      var node = this.startNode();\n      this.next();\n      node.argument = this.parseBindingAtom();\n      return this.finishNode(node, \"RestElement\");\n    }\n  }, {\n    key: \"parseBindingAtom\",\n    value: function parseBindingAtom() {\n      switch (this.state.type) {\n        case types.bracketL:\n          {\n            var node = this.startNode();\n            this.next();\n            node.elements = this.parseBindingList(types.bracketR, 93, true);\n            return this.finishNode(node, \"ArrayPattern\");\n          }\n\n        case types.braceL:\n          return this.parseObjectLike(types.braceR, true);\n      }\n\n      return this.parseIdentifier();\n    }\n  }, {\n    key: \"parseBindingList\",\n    value: function parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) {\n      var elts = [];\n      var first = true;\n\n      while (!this.eat(close)) {\n        if (first) {\n          first = false;\n        } else {\n          this.expect(types.comma);\n        }\n\n        if (allowEmpty && this.match(types.comma)) {\n          elts.push(null);\n        } else if (this.eat(close)) {\n          break;\n        } else if (this.match(types.ellipsis)) {\n          elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));\n          this.checkCommaAfterRest(closeCharCode);\n          this.expect(close);\n          break;\n        } else {\n          var decorators = [];\n\n          if (this.match(types.at) && this.hasPlugin(\"decorators\")) {\n            this.raise(this.state.start, ErrorMessages.UnsupportedParameterDecorator);\n          }\n\n          while (this.match(types.at)) {\n            decorators.push(this.parseDecorator());\n          }\n\n          elts.push(this.parseAssignableListItem(allowModifiers, decorators));\n        }\n      }\n\n      return elts;\n    }\n  }, {\n    key: \"parseAssignableListItem\",\n    value: function parseAssignableListItem(allowModifiers, decorators) {\n      var left = this.parseMaybeDefault();\n      this.parseAssignableListItemTypes(left);\n      var elt = this.parseMaybeDefault(left.start, left.loc.start, left);\n\n      if (decorators.length) {\n        left.decorators = decorators;\n      }\n\n      return elt;\n    }\n  }, {\n    key: \"parseAssignableListItemTypes\",\n    value: function parseAssignableListItemTypes(param) {\n      return param;\n    }\n  }, {\n    key: \"parseMaybeDefault\",\n    value: function parseMaybeDefault(startPos, startLoc, left) {\n      var _startLoc, _startPos, _left;\n\n      startLoc = (_startLoc = startLoc) != null ? _startLoc : this.state.startLoc;\n      startPos = (_startPos = startPos) != null ? _startPos : this.state.start;\n      left = (_left = left) != null ? _left : this.parseBindingAtom();\n      if (!this.eat(types.eq)) return left;\n      var node = this.startNodeAt(startPos, startLoc);\n      node.left = left;\n      node.right = this.parseMaybeAssignAllowIn();\n      return this.finishNode(node, \"AssignmentPattern\");\n    }\n  }, {\n    key: \"checkLVal\",\n    value: function checkLVal(expr) {\n      var bindingType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : BIND_NONE;\n      var checkClashes = arguments.length > 2 ? arguments[2] : undefined;\n      var contextDescription = arguments.length > 3 ? arguments[3] : undefined;\n      var disallowLetBinding = arguments.length > 4 ? arguments[4] : undefined;\n      var strictModeChanged = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n\n      switch (expr.type) {\n        case \"Identifier\":\n          if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(expr.name, this.inModule) : isStrictBindOnlyReservedWord(expr.name))) {\n            this.raise(expr.start, bindingType === BIND_NONE ? ErrorMessages.StrictEvalArguments : ErrorMessages.StrictEvalArgumentsBinding, expr.name);\n          }\n\n          if (checkClashes) {\n            var key = \"_\".concat(expr.name);\n\n            if (checkClashes[key]) {\n              this.raise(expr.start, ErrorMessages.ParamDupe);\n            } else {\n              checkClashes[key] = true;\n            }\n          }\n\n          if (disallowLetBinding && expr.name === \"let\") {\n            this.raise(expr.start, ErrorMessages.LetInLexicalBinding);\n          }\n\n          if (!(bindingType & BIND_NONE)) {\n            this.scope.declareName(expr.name, bindingType, expr.start);\n          }\n\n          break;\n\n        case \"MemberExpression\":\n          if (bindingType !== BIND_NONE) {\n            this.raise(expr.start, ErrorMessages.InvalidPropertyBindingPattern);\n          }\n\n          break;\n\n        case \"ObjectPattern\":\n          for (var _i2 = 0, _expr$properties = expr.properties; _i2 < _expr$properties.length; _i2++) {\n            var prop = _expr$properties[_i2];\n            if (prop.type === \"ObjectProperty\") prop = prop.value;else if (prop.type === \"ObjectMethod\") continue;\n            this.checkLVal(prop, bindingType, checkClashes, \"object destructuring pattern\", disallowLetBinding);\n          }\n\n          break;\n\n        case \"ArrayPattern\":\n          for (var _i3 = 0, _expr$elements = expr.elements; _i3 < _expr$elements.length; _i3++) {\n            var elem = _expr$elements[_i3];\n\n            if (elem) {\n              this.checkLVal(elem, bindingType, checkClashes, \"array destructuring pattern\", disallowLetBinding);\n            }\n          }\n\n          break;\n\n        case \"AssignmentPattern\":\n          this.checkLVal(expr.left, bindingType, checkClashes, \"assignment pattern\");\n          break;\n\n        case \"RestElement\":\n          this.checkLVal(expr.argument, bindingType, checkClashes, \"rest element\");\n          break;\n\n        case \"ParenthesizedExpression\":\n          this.checkLVal(expr.expression, bindingType, checkClashes, \"parenthesized expression\");\n          break;\n\n        default:\n          {\n            this.raise(expr.start, bindingType === BIND_NONE ? ErrorMessages.InvalidLhs : ErrorMessages.InvalidLhsBinding, contextDescription);\n          }\n      }\n    }\n  }, {\n    key: \"checkToRestConversion\",\n    value: function checkToRestConversion(node) {\n      if (node.argument.type !== \"Identifier\" && node.argument.type !== \"MemberExpression\") {\n        this.raise(node.argument.start, ErrorMessages.InvalidRestAssignmentPattern);\n      }\n    }\n  }, {\n    key: \"checkCommaAfterRest\",\n    value: function checkCommaAfterRest(close) {\n      if (this.match(types.comma)) {\n        if (this.lookaheadCharCode() === close) {\n          this.raiseTrailingCommaAfterRest(this.state.start);\n        } else {\n          this.raiseRestNotLast(this.state.start);\n        }\n      }\n    }\n  }, {\n    key: \"raiseRestNotLast\",\n    value: function raiseRestNotLast(pos) {\n      throw this.raise(pos, ErrorMessages.ElementAfterRest);\n    }\n  }, {\n    key: \"raiseTrailingCommaAfterRest\",\n    value: function raiseTrailingCommaAfterRest(pos) {\n      this.raise(pos, ErrorMessages.RestTrailingComma);\n    }\n  }]);\n\n  return LValParser;\n}(NodeUtils);\n\nvar ExpressionParser = /*#__PURE__*/function (_LValParser) {\n  _inherits(ExpressionParser, _LValParser);\n\n  var _super15 = _createSuper(ExpressionParser);\n\n  function ExpressionParser() {\n    _classCallCheck(this, ExpressionParser);\n\n    return _super15.apply(this, arguments);\n  }\n\n  _createClass(ExpressionParser, [{\n    key: \"checkProto\",\n    value: function checkProto(prop, isRecord, protoRef, refExpressionErrors) {\n      if (prop.type === \"SpreadElement\" || prop.type === \"ObjectMethod\" || prop.computed || prop.shorthand) {\n        return;\n      }\n\n      var key = prop.key;\n      var name = key.type === \"Identifier\" ? key.name : key.value;\n\n      if (name === \"__proto__\") {\n        if (isRecord) {\n          this.raise(key.start, ErrorMessages.RecordNoProto);\n          return;\n        }\n\n        if (protoRef.used) {\n          if (refExpressionErrors) {\n            if (refExpressionErrors.doubleProto === -1) {\n              refExpressionErrors.doubleProto = key.start;\n            }\n          } else {\n            this.raise(key.start, ErrorMessages.DuplicateProto);\n          }\n        }\n\n        protoRef.used = true;\n      }\n    }\n  }, {\n    key: \"shouldExitDescending\",\n    value: function shouldExitDescending(expr, potentialArrowAt) {\n      return expr.type === \"ArrowFunctionExpression\" && expr.start === potentialArrowAt;\n    }\n  }, {\n    key: \"getExpression\",\n    value: function getExpression() {\n      var paramFlags = PARAM;\n\n      if (this.hasPlugin(\"topLevelAwait\") && this.inModule) {\n        paramFlags |= PARAM_AWAIT;\n      }\n\n      this.scope.enter(SCOPE_PROGRAM);\n      this.prodParam.enter(paramFlags);\n      this.nextToken();\n      var expr = this.parseExpression();\n\n      if (!this.match(types.eof)) {\n        this.unexpected();\n      }\n\n      expr.comments = this.state.comments;\n      expr.errors = this.state.errors;\n      return expr;\n    }\n  }, {\n    key: \"parseExpression\",\n    value: function parseExpression(disallowIn, refExpressionErrors) {\n      var _this36 = this;\n\n      if (disallowIn) {\n        return this.disallowInAnd(function () {\n          return _this36.parseExpressionBase(refExpressionErrors);\n        });\n      }\n\n      return this.allowInAnd(function () {\n        return _this36.parseExpressionBase(refExpressionErrors);\n      });\n    }\n  }, {\n    key: \"parseExpressionBase\",\n    value: function parseExpressionBase(refExpressionErrors) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      var expr = this.parseMaybeAssign(refExpressionErrors);\n\n      if (this.match(types.comma)) {\n        var node = this.startNodeAt(startPos, startLoc);\n        node.expressions = [expr];\n\n        while (this.eat(types.comma)) {\n          node.expressions.push(this.parseMaybeAssign(refExpressionErrors));\n        }\n\n        this.toReferencedList(node.expressions);\n        return this.finishNode(node, \"SequenceExpression\");\n      }\n\n      return expr;\n    }\n  }, {\n    key: \"parseMaybeAssignDisallowIn\",\n    value: function parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {\n      var _this37 = this;\n\n      return this.disallowInAnd(function () {\n        return _this37.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos);\n      });\n    }\n  }, {\n    key: \"parseMaybeAssignAllowIn\",\n    value: function parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {\n      var _this38 = this;\n\n      return this.allowInAnd(function () {\n        return _this38.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos);\n      });\n    }\n  }, {\n    key: \"parseMaybeAssign\",\n    value: function parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n\n      if (this.isContextual(\"yield\")) {\n        if (this.prodParam.hasYield) {\n          var _left2 = this.parseYield();\n\n          if (afterLeftParse) {\n            _left2 = afterLeftParse.call(this, _left2, startPos, startLoc);\n          }\n\n          return _left2;\n        } else {\n          this.state.exprAllowed = false;\n        }\n      }\n\n      var ownExpressionErrors;\n\n      if (refExpressionErrors) {\n        ownExpressionErrors = false;\n      } else {\n        refExpressionErrors = new ExpressionErrors();\n        ownExpressionErrors = true;\n      }\n\n      if (this.match(types.parenL) || this.match(types.name)) {\n        this.state.potentialArrowAt = this.state.start;\n      }\n\n      var left = this.parseMaybeConditional(refExpressionErrors, refNeedsArrowPos);\n\n      if (afterLeftParse) {\n        left = afterLeftParse.call(this, left, startPos, startLoc);\n      }\n\n      if (this.state.type.isAssign) {\n        var node = this.startNodeAt(startPos, startLoc);\n        var operator = this.state.value;\n        node.operator = operator;\n\n        if (this.match(types.eq)) {\n          node.left = this.toAssignable(left);\n          refExpressionErrors.doubleProto = -1;\n        } else {\n          node.left = left;\n        }\n\n        if (refExpressionErrors.shorthandAssign >= node.left.start) {\n          refExpressionErrors.shorthandAssign = -1;\n        }\n\n        this.checkLVal(left, undefined, undefined, \"assignment expression\");\n        this.next();\n        node.right = this.parseMaybeAssign();\n        return this.finishNode(node, \"AssignmentExpression\");\n      } else if (ownExpressionErrors) {\n        this.checkExpressionErrors(refExpressionErrors, true);\n      }\n\n      return left;\n    }\n  }, {\n    key: \"parseMaybeConditional\",\n    value: function parseMaybeConditional(refExpressionErrors, refNeedsArrowPos) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      var potentialArrowAt = this.state.potentialArrowAt;\n      var expr = this.parseExprOps(refExpressionErrors);\n\n      if (this.shouldExitDescending(expr, potentialArrowAt)) {\n        return expr;\n      }\n\n      return this.parseConditional(expr, startPos, startLoc, refNeedsArrowPos);\n    }\n  }, {\n    key: \"parseConditional\",\n    value: function parseConditional(expr, startPos, startLoc, refNeedsArrowPos) {\n      if (this.eat(types.question)) {\n        var node = this.startNodeAt(startPos, startLoc);\n        node.test = expr;\n        node.consequent = this.parseMaybeAssignAllowIn();\n        this.expect(types.colon);\n        node.alternate = this.parseMaybeAssign();\n        return this.finishNode(node, \"ConditionalExpression\");\n      }\n\n      return expr;\n    }\n  }, {\n    key: \"parseExprOps\",\n    value: function parseExprOps(refExpressionErrors) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      var potentialArrowAt = this.state.potentialArrowAt;\n      var expr = this.parseMaybeUnary(refExpressionErrors);\n\n      if (this.shouldExitDescending(expr, potentialArrowAt)) {\n        return expr;\n      }\n\n      return this.parseExprOp(expr, startPos, startLoc, -1);\n    }\n  }, {\n    key: \"parseExprOp\",\n    value: function parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {\n      var prec = this.state.type.binop;\n\n      if (prec != null && (this.prodParam.hasIn || !this.match(types._in))) {\n        if (prec > minPrec) {\n          var op = this.state.type;\n\n          if (op === types.pipeline) {\n            this.expectPlugin(\"pipelineOperator\");\n\n            if (this.state.inFSharpPipelineDirectBody) {\n              return left;\n            }\n\n            this.state.inPipeline = true;\n            this.checkPipelineAtInfixOperator(left, leftStartPos);\n          }\n\n          var node = this.startNodeAt(leftStartPos, leftStartLoc);\n          node.left = left;\n          node.operator = this.state.value;\n\n          if (op === types.exponent && left.type === \"UnaryExpression\" && (this.options.createParenthesizedExpressions || !(left.extra && left.extra.parenthesized))) {\n            this.raise(left.argument.start, ErrorMessages.UnexpectedTokenUnaryExponentiation);\n          }\n\n          var logical = op === types.logicalOR || op === types.logicalAND;\n          var coalesce = op === types.nullishCoalescing;\n\n          if (coalesce) {\n            prec = types.logicalAND.binop;\n          }\n\n          this.next();\n\n          if (op === types.pipeline && this.getPluginOption(\"pipelineOperator\", \"proposal\") === \"minimal\") {\n            if (this.match(types.name) && this.state.value === \"await\" && this.prodParam.hasAwait) {\n              throw this.raise(this.state.start, ErrorMessages.UnexpectedAwaitAfterPipelineBody);\n            }\n          }\n\n          node.right = this.parseExprOpRightExpr(op, prec);\n          this.finishNode(node, logical || coalesce ? \"LogicalExpression\" : \"BinaryExpression\");\n          var nextOp = this.state.type;\n\n          if (coalesce && (nextOp === types.logicalOR || nextOp === types.logicalAND) || logical && nextOp === types.nullishCoalescing) {\n            throw this.raise(this.state.start, ErrorMessages.MixingCoalesceWithLogical);\n          }\n\n          return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);\n        }\n      }\n\n      return left;\n    }\n  }, {\n    key: \"parseExprOpRightExpr\",\n    value: function parseExprOpRightExpr(op, prec) {\n      var _this39 = this;\n\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n\n      switch (op) {\n        case types.pipeline:\n          switch (this.getPluginOption(\"pipelineOperator\", \"proposal\")) {\n            case \"smart\":\n              return this.withTopicPermittingContext(function () {\n                return _this39.parseSmartPipelineBody(_this39.parseExprOpBaseRightExpr(op, prec), startPos, startLoc);\n              });\n\n            case \"fsharp\":\n              return this.withSoloAwaitPermittingContext(function () {\n                return _this39.parseFSharpPipelineBody(prec);\n              });\n          }\n\n        default:\n          return this.parseExprOpBaseRightExpr(op, prec);\n      }\n    }\n  }, {\n    key: \"parseExprOpBaseRightExpr\",\n    value: function parseExprOpBaseRightExpr(op, prec) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      return this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, op.rightAssociative ? prec - 1 : prec);\n    }\n  }, {\n    key: \"parseMaybeUnary\",\n    value: function parseMaybeUnary(refExpressionErrors) {\n      if (this.isContextual(\"await\") && this.isAwaitAllowed()) {\n        return this.parseAwait();\n      }\n\n      var update = this.match(types.incDec);\n      var node = this.startNode();\n\n      if (this.state.type.prefix) {\n        node.operator = this.state.value;\n        node.prefix = true;\n\n        if (this.match(types._throw)) {\n          this.expectPlugin(\"throwExpressions\");\n        }\n\n        var isDelete = this.match(types._delete);\n        this.next();\n        node.argument = this.parseMaybeUnary();\n        this.checkExpressionErrors(refExpressionErrors, true);\n\n        if (this.state.strict && isDelete) {\n          var arg = node.argument;\n\n          if (arg.type === \"Identifier\") {\n            this.raise(node.start, ErrorMessages.StrictDelete);\n          } else if ((arg.type === \"MemberExpression\" || arg.type === \"OptionalMemberExpression\") && arg.property.type === \"PrivateName\") {\n            this.raise(node.start, ErrorMessages.DeletePrivateField);\n          }\n        }\n\n        if (!update) {\n          return this.finishNode(node, \"UnaryExpression\");\n        }\n      }\n\n      return this.parseUpdate(node, update, refExpressionErrors);\n    }\n  }, {\n    key: \"parseUpdate\",\n    value: function parseUpdate(node, update, refExpressionErrors) {\n      if (update) {\n        this.checkLVal(node.argument, undefined, undefined, \"prefix operation\");\n        return this.finishNode(node, \"UpdateExpression\");\n      }\n\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      var expr = this.parseExprSubscripts(refExpressionErrors);\n      if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;\n\n      while (this.state.type.postfix && !this.canInsertSemicolon()) {\n        var _node10 = this.startNodeAt(startPos, startLoc);\n\n        _node10.operator = this.state.value;\n        _node10.prefix = false;\n        _node10.argument = expr;\n        this.checkLVal(expr, undefined, undefined, \"postfix operation\");\n        this.next();\n        expr = this.finishNode(_node10, \"UpdateExpression\");\n      }\n\n      return expr;\n    }\n  }, {\n    key: \"parseExprSubscripts\",\n    value: function parseExprSubscripts(refExpressionErrors) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      var potentialArrowAt = this.state.potentialArrowAt;\n      var expr = this.parseExprAtom(refExpressionErrors);\n\n      if (this.shouldExitDescending(expr, potentialArrowAt)) {\n        return expr;\n      }\n\n      return this.parseSubscripts(expr, startPos, startLoc);\n    }\n  }, {\n    key: \"parseSubscripts\",\n    value: function parseSubscripts(base, startPos, startLoc, noCalls) {\n      var state = {\n        optionalChainMember: false,\n        maybeAsyncArrow: this.atPossibleAsyncArrow(base),\n        stop: false\n      };\n\n      do {\n        var oldMaybeInAsyncArrowHead = this.state.maybeInAsyncArrowHead;\n\n        if (state.maybeAsyncArrow) {\n          this.state.maybeInAsyncArrowHead = true;\n        }\n\n        base = this.parseSubscript(base, startPos, startLoc, noCalls, state);\n        state.maybeAsyncArrow = false;\n        this.state.maybeInAsyncArrowHead = oldMaybeInAsyncArrowHead;\n      } while (!state.stop);\n\n      return base;\n    }\n  }, {\n    key: \"parseSubscript\",\n    value: function parseSubscript(base, startPos, startLoc, noCalls, state) {\n      if (!noCalls && this.eat(types.doubleColon)) {\n        return this.parseBind(base, startPos, startLoc, noCalls, state);\n      } else if (this.match(types.backQuote)) {\n        return this.parseTaggedTemplateExpression(base, startPos, startLoc, state);\n      }\n\n      var optional = false;\n\n      if (this.match(types.questionDot)) {\n        state.optionalChainMember = optional = true;\n\n        if (noCalls && this.lookaheadCharCode() === 40) {\n          state.stop = true;\n          return base;\n        }\n\n        this.next();\n      }\n\n      if (!noCalls && this.match(types.parenL)) {\n        return this.parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional);\n      } else if (optional || this.match(types.bracketL) || this.eat(types.dot)) {\n        return this.parseMember(base, startPos, startLoc, state, optional);\n      } else {\n        state.stop = true;\n        return base;\n      }\n    }\n  }, {\n    key: \"parseMember\",\n    value: function parseMember(base, startPos, startLoc, state, optional) {\n      var node = this.startNodeAt(startPos, startLoc);\n      var computed = this.eat(types.bracketL);\n      node.object = base;\n      node.computed = computed;\n      var property = computed ? this.parseExpression() : this.parseMaybePrivateName(true);\n\n      if (property.type === \"PrivateName\") {\n        if (node.object.type === \"Super\") {\n          this.raise(startPos, ErrorMessages.SuperPrivateField);\n        }\n\n        this.classScope.usePrivateName(property.id.name, property.start);\n      }\n\n      node.property = property;\n\n      if (computed) {\n        this.expect(types.bracketR);\n      }\n\n      if (state.optionalChainMember) {\n        node.optional = optional;\n        return this.finishNode(node, \"OptionalMemberExpression\");\n      } else {\n        return this.finishNode(node, \"MemberExpression\");\n      }\n    }\n  }, {\n    key: \"parseBind\",\n    value: function parseBind(base, startPos, startLoc, noCalls, state) {\n      var node = this.startNodeAt(startPos, startLoc);\n      node.object = base;\n      node.callee = this.parseNoCallExpr();\n      state.stop = true;\n      return this.parseSubscripts(this.finishNode(node, \"BindExpression\"), startPos, startLoc, noCalls);\n    }\n  }, {\n    key: \"parseCoverCallAndAsyncArrowHead\",\n    value: function parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional) {\n      var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      var oldYieldPos = this.state.yieldPos;\n      var oldAwaitPos = this.state.awaitPos;\n      this.state.maybeInArrowParameters = true;\n      this.state.yieldPos = -1;\n      this.state.awaitPos = -1;\n      this.next();\n      var node = this.startNodeAt(startPos, startLoc);\n      node.callee = base;\n\n      if (state.optionalChainMember) {\n        node.optional = optional;\n      }\n\n      if (optional) {\n        node.arguments = this.parseCallExpressionArguments(types.parenR, false);\n      } else {\n        node.arguments = this.parseCallExpressionArguments(types.parenR, state.maybeAsyncArrow, base.type === \"Import\", base.type !== \"Super\", node);\n      }\n\n      this.finishCallExpression(node, state.optionalChainMember);\n\n      if (state.maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {\n        state.stop = true;\n        node = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);\n        this.checkYieldAwaitInDefaultParams();\n        this.state.yieldPos = oldYieldPos;\n        this.state.awaitPos = oldAwaitPos;\n      } else {\n        this.toReferencedListDeep(node.arguments);\n        if (oldYieldPos !== -1) this.state.yieldPos = oldYieldPos;\n\n        if (!this.isAwaitAllowed() && !oldMaybeInArrowParameters || oldAwaitPos !== -1) {\n          this.state.awaitPos = oldAwaitPos;\n        }\n      }\n\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n      return node;\n    }\n  }, {\n    key: \"parseTaggedTemplateExpression\",\n    value: function parseTaggedTemplateExpression(base, startPos, startLoc, state) {\n      var node = this.startNodeAt(startPos, startLoc);\n      node.tag = base;\n      node.quasi = this.parseTemplate(true);\n\n      if (state.optionalChainMember) {\n        this.raise(startPos, ErrorMessages.OptionalChainingNoTemplate);\n      }\n\n      return this.finishNode(node, \"TaggedTemplateExpression\");\n    }\n  }, {\n    key: \"atPossibleAsyncArrow\",\n    value: function atPossibleAsyncArrow(base) {\n      return base.type === \"Identifier\" && base.name === \"async\" && this.state.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;\n    }\n  }, {\n    key: \"finishCallExpression\",\n    value: function finishCallExpression(node, optional) {\n      if (node.callee.type === \"Import\") {\n        if (node.arguments.length === 2) {\n          this.expectPlugin(\"moduleAttributes\");\n        }\n\n        if (node.arguments.length === 0 || node.arguments.length > 2) {\n          this.raise(node.start, ErrorMessages.ImportCallArity, this.hasPlugin(\"moduleAttributes\") ? \"one or two arguments\" : \"one argument\");\n        } else {\n          for (var _i = 0, _node$arguments = node.arguments; _i < _node$arguments.length; _i++) {\n            var arg = _node$arguments[_i];\n\n            if (arg.type === \"SpreadElement\") {\n              this.raise(arg.start, ErrorMessages.ImportCallSpreadArgument);\n            }\n          }\n        }\n      }\n\n      return this.finishNode(node, optional ? \"OptionalCallExpression\" : \"CallExpression\");\n    }\n  }, {\n    key: \"parseCallExpressionArguments\",\n    value: function parseCallExpressionArguments(close, possibleAsyncArrow, dynamicImport, allowPlaceholder, nodeForExtra) {\n      var elts = [];\n      var innerParenStart;\n      var first = true;\n      var oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n      this.state.inFSharpPipelineDirectBody = false;\n\n      while (!this.eat(close)) {\n        if (first) {\n          first = false;\n        } else {\n          this.expect(types.comma);\n\n          if (this.match(close)) {\n            if (dynamicImport && !this.hasPlugin(\"moduleAttributes\")) {\n              this.raise(this.state.lastTokStart, ErrorMessages.ImportCallArgumentTrailingComma);\n            }\n\n            if (nodeForExtra) {\n              this.addExtra(nodeForExtra, \"trailingComma\", this.state.lastTokStart);\n            }\n\n            this.next();\n            break;\n          }\n        }\n\n        if (this.match(types.parenL) && !innerParenStart) {\n          innerParenStart = this.state.start;\n        }\n\n        elts.push(this.parseExprListItem(false, possibleAsyncArrow ? new ExpressionErrors() : undefined, possibleAsyncArrow ? {\n          start: 0\n        } : undefined, allowPlaceholder));\n      }\n\n      if (possibleAsyncArrow && innerParenStart && this.shouldParseAsyncArrow()) {\n        this.unexpected();\n      }\n\n      this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n      return elts;\n    }\n  }, {\n    key: \"shouldParseAsyncArrow\",\n    value: function shouldParseAsyncArrow() {\n      return this.match(types.arrow) && !this.canInsertSemicolon();\n    }\n  }, {\n    key: \"parseAsyncArrowFromCallExpression\",\n    value: function parseAsyncArrowFromCallExpression(node, call) {\n      var _call$extra;\n\n      this.expect(types.arrow);\n      this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingComma);\n      return node;\n    }\n  }, {\n    key: \"parseNoCallExpr\",\n    value: function parseNoCallExpr() {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);\n    }\n  }, {\n    key: \"parseExprAtom\",\n    value: function parseExprAtom(refExpressionErrors) {\n      if (this.state.type === types.slash) this.readRegexp();\n      var canBeArrow = this.state.potentialArrowAt === this.state.start;\n      var node;\n\n      switch (this.state.type) {\n        case types._super:\n          return this.parseSuper();\n\n        case types._import:\n          node = this.startNode();\n          this.next();\n\n          if (this.match(types.dot)) {\n            return this.parseImportMetaProperty(node);\n          }\n\n          if (!this.match(types.parenL)) {\n            this.raise(this.state.lastTokStart, ErrorMessages.UnsupportedImport);\n          }\n\n          return this.finishNode(node, \"Import\");\n\n        case types._this:\n          node = this.startNode();\n          this.next();\n          return this.finishNode(node, \"ThisExpression\");\n\n        case types.name:\n          {\n            var containsEsc = this.state.containsEsc;\n            var id = this.parseIdentifier();\n\n            if (!containsEsc && id.name === \"async\" && !this.canInsertSemicolon()) {\n              if (this.match(types._function)) {\n                var _last4 = this.state.context.length - 1;\n\n                if (this.state.context[_last4] !== types$1.functionStatement) {\n                  throw new Error(\"Internal error\");\n                }\n\n                this.state.context[_last4] = types$1.functionExpression;\n                this.next();\n                return this.parseFunction(this.startNodeAtNode(id), undefined, true);\n              } else if (this.match(types.name)) {\n                return this.parseAsyncArrowUnaryFunction(id);\n              }\n            }\n\n            if (canBeArrow && this.match(types.arrow) && !this.canInsertSemicolon()) {\n              this.next();\n              return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);\n            }\n\n            return id;\n          }\n\n        case types._do:\n          {\n            return this.parseDo();\n          }\n\n        case types.regexp:\n          {\n            var value = this.state.value;\n            node = this.parseLiteral(value.value, \"RegExpLiteral\");\n            node.pattern = value.pattern;\n            node.flags = value.flags;\n            return node;\n          }\n\n        case types.num:\n          return this.parseLiteral(this.state.value, \"NumericLiteral\");\n\n        case types.bigint:\n          return this.parseLiteral(this.state.value, \"BigIntLiteral\");\n\n        case types.decimal:\n          return this.parseLiteral(this.state.value, \"DecimalLiteral\");\n\n        case types.string:\n          return this.parseLiteral(this.state.value, \"StringLiteral\");\n\n        case types._null:\n          node = this.startNode();\n          this.next();\n          return this.finishNode(node, \"NullLiteral\");\n\n        case types._true:\n        case types._false:\n          return this.parseBooleanLiteral();\n\n        case types.parenL:\n          return this.parseParenAndDistinguishExpression(canBeArrow);\n\n        case types.bracketBarL:\n        case types.bracketHashL:\n          {\n            return this.parseArrayLike(this.state.type === types.bracketBarL ? types.bracketBarR : types.bracketR, false, true, refExpressionErrors);\n          }\n\n        case types.bracketL:\n          {\n            return this.parseArrayLike(types.bracketR, true, false, refExpressionErrors);\n          }\n\n        case types.braceBarL:\n        case types.braceHashL:\n          {\n            return this.parseObjectLike(this.state.type === types.braceBarL ? types.braceBarR : types.braceR, false, true, refExpressionErrors);\n          }\n\n        case types.braceL:\n          {\n            return this.parseObjectLike(types.braceR, false, false, refExpressionErrors);\n          }\n\n        case types._function:\n          return this.parseFunctionOrFunctionSent();\n\n        case types.at:\n          this.parseDecorators();\n\n        case types._class:\n          node = this.startNode();\n          this.takeDecorators(node);\n          return this.parseClass(node, false);\n\n        case types._new:\n          return this.parseNewOrNewTarget();\n\n        case types.backQuote:\n          return this.parseTemplate(false);\n\n        case types.doubleColon:\n          {\n            node = this.startNode();\n            this.next();\n            node.object = null;\n            var callee = node.callee = this.parseNoCallExpr();\n\n            if (callee.type === \"MemberExpression\") {\n              return this.finishNode(node, \"BindExpression\");\n            } else {\n              throw this.raise(callee.start, ErrorMessages.UnsupportedBind);\n            }\n          }\n\n        case types.hash:\n          {\n            if (this.state.inPipeline) {\n              node = this.startNode();\n\n              if (this.getPluginOption(\"pipelineOperator\", \"proposal\") !== \"smart\") {\n                this.raise(node.start, ErrorMessages.PrimaryTopicRequiresSmartPipeline);\n              }\n\n              this.next();\n\n              if (!this.primaryTopicReferenceIsAllowedInCurrentTopicContext()) {\n                this.raise(node.start, ErrorMessages.PrimaryTopicNotAllowed);\n              }\n\n              this.registerTopicReference();\n              return this.finishNode(node, \"PipelinePrimaryTopicReference\");\n            }\n\n            var nextCh = this.input.codePointAt(this.state.end);\n\n            if (isIdentifierStart(nextCh) || nextCh === 92) {\n              var start = this.state.start;\n              node = this.parseMaybePrivateName(true);\n\n              if (this.match(types._in)) {\n                this.expectPlugin(\"privateIn\");\n                this.classScope.usePrivateName(node.id.name, node.start);\n              } else if (this.hasPlugin(\"privateIn\")) {\n                this.raise(this.state.start, ErrorMessages.PrivateInExpectedIn, node.id.name);\n              } else {\n                throw this.unexpected(start);\n              }\n\n              return node;\n            }\n          }\n\n        case types.relational:\n          {\n            if (this.state.value === \"<\") {\n              var lookaheadCh = this.input.codePointAt(this.nextTokenStart());\n\n              if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {\n                this.expectOnePlugin([\"jsx\", \"flow\", \"typescript\"]);\n              }\n            }\n          }\n\n        default:\n          throw this.unexpected();\n      }\n    }\n  }, {\n    key: \"parseAsyncArrowUnaryFunction\",\n    value: function parseAsyncArrowUnaryFunction(id) {\n      var node = this.startNodeAtNode(id);\n      var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      var oldMaybeInAsyncArrowHead = this.state.maybeInAsyncArrowHead;\n      var oldYieldPos = this.state.yieldPos;\n      var oldAwaitPos = this.state.awaitPos;\n      this.state.maybeInArrowParameters = true;\n      this.state.maybeInAsyncArrowHead = true;\n      this.state.yieldPos = -1;\n      this.state.awaitPos = -1;\n      var params = [this.parseIdentifier()];\n\n      if (this.hasPrecedingLineBreak()) {\n        this.raise(this.state.pos, ErrorMessages.LineTerminatorBeforeArrow);\n      }\n\n      this.expect(types.arrow);\n      this.checkYieldAwaitInDefaultParams();\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n      this.state.maybeInAsyncArrowHead = oldMaybeInAsyncArrowHead;\n      this.state.yieldPos = oldYieldPos;\n      this.state.awaitPos = oldAwaitPos;\n      this.parseArrowExpression(node, params, true);\n      return node;\n    }\n  }, {\n    key: \"parseDo\",\n    value: function parseDo() {\n      this.expectPlugin(\"doExpressions\");\n      var node = this.startNode();\n      this.next();\n      var oldLabels = this.state.labels;\n      this.state.labels = [];\n      node.body = this.parseBlock();\n      this.state.labels = oldLabels;\n      return this.finishNode(node, \"DoExpression\");\n    }\n  }, {\n    key: \"parseSuper\",\n    value: function parseSuper() {\n      var node = this.startNode();\n      this.next();\n\n      if (this.match(types.parenL) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {\n        this.raise(node.start, ErrorMessages.SuperNotAllowed);\n      } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {\n        this.raise(node.start, ErrorMessages.UnexpectedSuper);\n      }\n\n      if (!this.match(types.parenL) && !this.match(types.bracketL) && !this.match(types.dot)) {\n        this.raise(node.start, ErrorMessages.UnsupportedSuper);\n      }\n\n      return this.finishNode(node, \"Super\");\n    }\n  }, {\n    key: \"parseBooleanLiteral\",\n    value: function parseBooleanLiteral() {\n      var node = this.startNode();\n      node.value = this.match(types._true);\n      this.next();\n      return this.finishNode(node, \"BooleanLiteral\");\n    }\n  }, {\n    key: \"parseMaybePrivateName\",\n    value: function parseMaybePrivateName(isPrivateNameAllowed) {\n      var isPrivate = this.match(types.hash);\n\n      if (isPrivate) {\n        this.expectOnePlugin([\"classPrivateProperties\", \"classPrivateMethods\"]);\n\n        if (!isPrivateNameAllowed) {\n          this.raise(this.state.pos, ErrorMessages.UnexpectedPrivateField);\n        }\n\n        var node = this.startNode();\n        this.next();\n        this.assertNoSpace(\"Unexpected space between # and identifier\");\n        node.id = this.parseIdentifier(true);\n        return this.finishNode(node, \"PrivateName\");\n      } else {\n        return this.parseIdentifier(true);\n      }\n    }\n  }, {\n    key: \"parseFunctionOrFunctionSent\",\n    value: function parseFunctionOrFunctionSent() {\n      var node = this.startNode();\n      this.next();\n\n      if (this.prodParam.hasYield && this.match(types.dot)) {\n        var meta = this.createIdentifier(this.startNodeAtNode(node), \"function\");\n        this.next();\n        return this.parseMetaProperty(node, meta, \"sent\");\n      }\n\n      return this.parseFunction(node);\n    }\n  }, {\n    key: \"parseMetaProperty\",\n    value: function parseMetaProperty(node, meta, propertyName) {\n      node.meta = meta;\n\n      if (meta.name === \"function\" && propertyName === \"sent\") {\n        if (this.isContextual(propertyName)) {\n          this.expectPlugin(\"functionSent\");\n        } else if (!this.hasPlugin(\"functionSent\")) {\n          this.unexpected();\n        }\n      }\n\n      var containsEsc = this.state.containsEsc;\n      node.property = this.parseIdentifier(true);\n\n      if (node.property.name !== propertyName || containsEsc) {\n        this.raise(node.property.start, ErrorMessages.UnsupportedMetaProperty, meta.name, propertyName);\n      }\n\n      return this.finishNode(node, \"MetaProperty\");\n    }\n  }, {\n    key: \"parseImportMetaProperty\",\n    value: function parseImportMetaProperty(node) {\n      var id = this.createIdentifier(this.startNodeAtNode(node), \"import\");\n      this.next();\n\n      if (this.isContextual(\"meta\")) {\n        if (!this.inModule) {\n          this.raiseWithData(id.start, {\n            code: \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\"\n          }, ErrorMessages.ImportMetaOutsideModule);\n        }\n\n        this.sawUnambiguousESM = true;\n      }\n\n      return this.parseMetaProperty(node, id, \"meta\");\n    }\n  }, {\n    key: \"parseLiteral\",\n    value: function parseLiteral(value, type, startPos, startLoc) {\n      startPos = startPos || this.state.start;\n      startLoc = startLoc || this.state.startLoc;\n      var node = this.startNodeAt(startPos, startLoc);\n      this.addExtra(node, \"rawValue\", value);\n      this.addExtra(node, \"raw\", this.input.slice(startPos, this.state.end));\n      node.value = value;\n      this.next();\n      return this.finishNode(node, type);\n    }\n  }, {\n    key: \"parseParenAndDistinguishExpression\",\n    value: function parseParenAndDistinguishExpression(canBeArrow) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      var val;\n      this.next();\n      var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      var oldYieldPos = this.state.yieldPos;\n      var oldAwaitPos = this.state.awaitPos;\n      var oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n      this.state.maybeInArrowParameters = true;\n      this.state.yieldPos = -1;\n      this.state.awaitPos = -1;\n      this.state.inFSharpPipelineDirectBody = false;\n      var innerStartPos = this.state.start;\n      var innerStartLoc = this.state.startLoc;\n      var exprList = [];\n      var refExpressionErrors = new ExpressionErrors();\n      var refNeedsArrowPos = {\n        start: 0\n      };\n      var first = true;\n      var spreadStart;\n      var optionalCommaStart;\n\n      while (!this.match(types.parenR)) {\n        if (first) {\n          first = false;\n        } else {\n          this.expect(types.comma, refNeedsArrowPos.start || null);\n\n          if (this.match(types.parenR)) {\n            optionalCommaStart = this.state.start;\n            break;\n          }\n        }\n\n        if (this.match(types.ellipsis)) {\n          var spreadNodeStartPos = this.state.start;\n          var spreadNodeStartLoc = this.state.startLoc;\n          spreadStart = this.state.start;\n          exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc));\n          this.checkCommaAfterRest(41);\n          break;\n        } else {\n          exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem, refNeedsArrowPos));\n        }\n      }\n\n      var innerEndPos = this.state.lastTokEnd;\n      var innerEndLoc = this.state.lastTokEndLoc;\n      this.expect(types.parenR);\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n      this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n      var arrowNode = this.startNodeAt(startPos, startLoc);\n\n      if (canBeArrow && this.shouldParseArrow() && (arrowNode = this.parseArrow(arrowNode))) {\n        if (!this.isAwaitAllowed() && !this.state.maybeInAsyncArrowHead) {\n          this.state.awaitPos = oldAwaitPos;\n        }\n\n        this.checkYieldAwaitInDefaultParams();\n        this.state.yieldPos = oldYieldPos;\n        this.state.awaitPos = oldAwaitPos;\n\n        for (var _i2 = 0; _i2 < exprList.length; _i2++) {\n          var param = exprList[_i2];\n\n          if (param.extra && param.extra.parenthesized) {\n            this.unexpected(param.extra.parenStart);\n          }\n        }\n\n        this.parseArrowExpression(arrowNode, exprList, false);\n        return arrowNode;\n      }\n\n      if (oldYieldPos !== -1) this.state.yieldPos = oldYieldPos;\n      if (oldAwaitPos !== -1) this.state.awaitPos = oldAwaitPos;\n\n      if (!exprList.length) {\n        this.unexpected(this.state.lastTokStart);\n      }\n\n      if (optionalCommaStart) this.unexpected(optionalCommaStart);\n      if (spreadStart) this.unexpected(spreadStart);\n      this.checkExpressionErrors(refExpressionErrors, true);\n      if (refNeedsArrowPos.start) this.unexpected(refNeedsArrowPos.start);\n      this.toReferencedListDeep(exprList, true);\n\n      if (exprList.length > 1) {\n        val = this.startNodeAt(innerStartPos, innerStartLoc);\n        val.expressions = exprList;\n        this.finishNodeAt(val, \"SequenceExpression\", innerEndPos, innerEndLoc);\n      } else {\n        val = exprList[0];\n      }\n\n      if (!this.options.createParenthesizedExpressions) {\n        this.addExtra(val, \"parenthesized\", true);\n        this.addExtra(val, \"parenStart\", startPos);\n        return val;\n      }\n\n      var parenExpression = this.startNodeAt(startPos, startLoc);\n      parenExpression.expression = val;\n      this.finishNode(parenExpression, \"ParenthesizedExpression\");\n      return parenExpression;\n    }\n  }, {\n    key: \"shouldParseArrow\",\n    value: function shouldParseArrow() {\n      return !this.canInsertSemicolon();\n    }\n  }, {\n    key: \"parseArrow\",\n    value: function parseArrow(node) {\n      if (this.eat(types.arrow)) {\n        return node;\n      }\n    }\n  }, {\n    key: \"parseParenItem\",\n    value: function parseParenItem(node, startPos, startLoc) {\n      return node;\n    }\n  }, {\n    key: \"parseNewOrNewTarget\",\n    value: function parseNewOrNewTarget() {\n      var node = this.startNode();\n      this.next();\n\n      if (this.match(types.dot)) {\n        var meta = this.createIdentifier(this.startNodeAtNode(node), \"new\");\n        this.next();\n        var metaProp = this.parseMetaProperty(node, meta, \"target\");\n\n        if (!this.scope.inNonArrowFunction && !this.scope.inClass) {\n          var error = ErrorMessages.UnexpectedNewTarget;\n\n          if (this.hasPlugin(\"classProperties\")) {\n            error += \" or class properties\";\n          }\n\n          this.raise(metaProp.start, error);\n        }\n\n        return metaProp;\n      }\n\n      return this.parseNew(node);\n    }\n  }, {\n    key: \"parseNew\",\n    value: function parseNew(node) {\n      node.callee = this.parseNoCallExpr();\n\n      if (node.callee.type === \"Import\") {\n        this.raise(node.callee.start, ErrorMessages.ImportCallNotNewExpression);\n      } else if (node.callee.type === \"OptionalMemberExpression\" || node.callee.type === \"OptionalCallExpression\") {\n        this.raise(this.state.lastTokEnd, ErrorMessages.OptionalChainingNoNew);\n      } else if (this.eat(types.questionDot)) {\n        this.raise(this.state.start, ErrorMessages.OptionalChainingNoNew);\n      }\n\n      this.parseNewArguments(node);\n      return this.finishNode(node, \"NewExpression\");\n    }\n  }, {\n    key: \"parseNewArguments\",\n    value: function parseNewArguments(node) {\n      if (this.eat(types.parenL)) {\n        var args = this.parseExprList(types.parenR);\n        this.toReferencedList(args);\n        node.arguments = args;\n      } else {\n        node.arguments = [];\n      }\n    }\n  }, {\n    key: \"parseTemplateElement\",\n    value: function parseTemplateElement(isTagged) {\n      var elem = this.startNode();\n\n      if (this.state.value === null) {\n        if (!isTagged) {\n          this.raise(this.state.start + 1, ErrorMessages.InvalidEscapeSequenceTemplate);\n        }\n      }\n\n      elem.value = {\n        raw: this.input.slice(this.state.start, this.state.end).replace(/\\r\\n?/g, \"\\n\"),\n        cooked: this.state.value\n      };\n      this.next();\n      elem.tail = this.match(types.backQuote);\n      return this.finishNode(elem, \"TemplateElement\");\n    }\n  }, {\n    key: \"parseTemplate\",\n    value: function parseTemplate(isTagged) {\n      var node = this.startNode();\n      this.next();\n      node.expressions = [];\n      var curElt = this.parseTemplateElement(isTagged);\n      node.quasis = [curElt];\n\n      while (!curElt.tail) {\n        this.expect(types.dollarBraceL);\n        node.expressions.push(this.parseExpression());\n        this.expect(types.braceR);\n        node.quasis.push(curElt = this.parseTemplateElement(isTagged));\n      }\n\n      this.next();\n      return this.finishNode(node, \"TemplateLiteral\");\n    }\n  }, {\n    key: \"parseObjectLike\",\n    value: function parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {\n      if (isRecord) {\n        this.expectPlugin(\"recordAndTuple\");\n      }\n\n      var oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n      this.state.inFSharpPipelineDirectBody = false;\n      var propHash = Object.create(null);\n      var first = true;\n      var node = this.startNode();\n      node.properties = [];\n      this.next();\n\n      while (!this.eat(close)) {\n        if (first) {\n          first = false;\n        } else {\n          this.expect(types.comma);\n\n          if (this.match(close)) {\n            this.addExtra(node, \"trailingComma\", this.state.lastTokStart);\n            this.next();\n            break;\n          }\n        }\n\n        var prop = this.parsePropertyDefinition(isPattern, refExpressionErrors);\n\n        if (!isPattern) {\n          this.checkProto(prop, isRecord, propHash, refExpressionErrors);\n        }\n\n        if (isRecord && prop.type !== \"ObjectProperty\" && prop.type !== \"SpreadElement\") {\n          this.raise(prop.start, ErrorMessages.InvalidRecordProperty);\n        }\n\n        if (prop.shorthand) {\n          this.addExtra(prop, \"shorthand\", true);\n        }\n\n        node.properties.push(prop);\n      }\n\n      this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n      var type = \"ObjectExpression\";\n\n      if (isPattern) {\n        type = \"ObjectPattern\";\n      } else if (isRecord) {\n        type = \"RecordExpression\";\n      }\n\n      return this.finishNode(node, type);\n    }\n  }, {\n    key: \"maybeAsyncOrAccessorProp\",\n    value: function maybeAsyncOrAccessorProp(prop) {\n      return !prop.computed && prop.key.type === \"Identifier\" && (this.isLiteralPropertyName() || this.match(types.bracketL) || this.match(types.star));\n    }\n  }, {\n    key: \"parsePropertyDefinition\",\n    value: function parsePropertyDefinition(isPattern, refExpressionErrors) {\n      var decorators = [];\n\n      if (this.match(types.at)) {\n        if (this.hasPlugin(\"decorators\")) {\n          this.raise(this.state.start, ErrorMessages.UnsupportedPropertyDecorator);\n        }\n\n        while (this.match(types.at)) {\n          decorators.push(this.parseDecorator());\n        }\n      }\n\n      var prop = this.startNode();\n      var isGenerator = false;\n      var isAsync = false;\n      var isAccessor = false;\n      var startPos;\n      var startLoc;\n\n      if (this.match(types.ellipsis)) {\n        if (decorators.length) this.unexpected();\n\n        if (isPattern) {\n          this.next();\n          prop.argument = this.parseIdentifier();\n          this.checkCommaAfterRest(125);\n          return this.finishNode(prop, \"RestElement\");\n        }\n\n        return this.parseSpread();\n      }\n\n      if (decorators.length) {\n        prop.decorators = decorators;\n        decorators = [];\n      }\n\n      prop.method = false;\n\n      if (isPattern || refExpressionErrors) {\n        startPos = this.state.start;\n        startLoc = this.state.startLoc;\n      }\n\n      if (!isPattern) {\n        isGenerator = this.eat(types.star);\n      }\n\n      var containsEsc = this.state.containsEsc;\n      var key = this.parsePropertyName(prop, false);\n\n      if (!isPattern && !isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {\n        var keyName = key.name;\n\n        if (keyName === \"async\" && !this.hasPrecedingLineBreak()) {\n          isAsync = true;\n          isGenerator = this.eat(types.star);\n          this.parsePropertyName(prop, false);\n        }\n\n        if (keyName === \"get\" || keyName === \"set\") {\n          isAccessor = true;\n          prop.kind = keyName;\n\n          if (this.match(types.star)) {\n            isGenerator = true;\n            this.raise(this.state.pos, ErrorMessages.AccessorIsGenerator, keyName);\n            this.next();\n          }\n\n          this.parsePropertyName(prop, false);\n        }\n      }\n\n      this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);\n      return prop;\n    }\n  }, {\n    key: \"getGetterSetterExpectedParamCount\",\n    value: function getGetterSetterExpectedParamCount(method) {\n      return method.kind === \"get\" ? 0 : 1;\n    }\n  }, {\n    key: \"checkGetterSetterParams\",\n    value: function checkGetterSetterParams(method) {\n      var paramCount = this.getGetterSetterExpectedParamCount(method);\n      var start = method.start;\n\n      if (method.params.length !== paramCount) {\n        if (method.kind === \"get\") {\n          this.raise(start, ErrorMessages.BadGetterArity);\n        } else {\n          this.raise(start, ErrorMessages.BadSetterArity);\n        }\n      }\n\n      if (method.kind === \"set\" && method.params[method.params.length - 1].type === \"RestElement\") {\n        this.raise(start, ErrorMessages.BadSetterRestParameter);\n      }\n    }\n  }, {\n    key: \"parseObjectMethod\",\n    value: function parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {\n      if (isAccessor) {\n        this.parseMethod(prop, isGenerator, false, false, false, \"ObjectMethod\");\n        this.checkGetterSetterParams(prop);\n        return prop;\n      }\n\n      if (isAsync || isGenerator || this.match(types.parenL)) {\n        if (isPattern) this.unexpected();\n        prop.kind = \"method\";\n        prop.method = true;\n        return this.parseMethod(prop, isGenerator, isAsync, false, false, \"ObjectMethod\");\n      }\n    }\n  }, {\n    key: \"parseObjectProperty\",\n    value: function parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {\n      prop.shorthand = false;\n\n      if (this.eat(types.colon)) {\n        prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);\n        return this.finishNode(prop, \"ObjectProperty\");\n      }\n\n      if (!prop.computed && prop.key.type === \"Identifier\") {\n        this.checkReservedWord(prop.key.name, prop.key.start, true, false);\n\n        if (isPattern) {\n          prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());\n        } else if (this.match(types.eq) && refExpressionErrors) {\n          if (refExpressionErrors.shorthandAssign === -1) {\n            refExpressionErrors.shorthandAssign = this.state.start;\n          }\n\n          prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());\n        } else {\n          prop.value = prop.key.__clone();\n        }\n\n        prop.shorthand = true;\n        return this.finishNode(prop, \"ObjectProperty\");\n      }\n    }\n  }, {\n    key: \"parseObjPropValue\",\n    value: function parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n      var node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors);\n      if (!node) this.unexpected();\n      return node;\n    }\n  }, {\n    key: \"parsePropertyName\",\n    value: function parsePropertyName(prop, isPrivateNameAllowed) {\n      if (this.eat(types.bracketL)) {\n        prop.computed = true;\n        prop.key = this.parseMaybeAssignAllowIn();\n        this.expect(types.bracketR);\n      } else {\n        var oldInPropertyName = this.state.inPropertyName;\n        this.state.inPropertyName = true;\n        prop.key = this.match(types.num) || this.match(types.string) || this.match(types.bigint) || this.match(types.decimal) ? this.parseExprAtom() : this.parseMaybePrivateName(isPrivateNameAllowed);\n\n        if (prop.key.type !== \"PrivateName\") {\n          prop.computed = false;\n        }\n\n        this.state.inPropertyName = oldInPropertyName;\n      }\n\n      return prop.key;\n    }\n  }, {\n    key: \"initFunction\",\n    value: function initFunction(node, isAsync) {\n      node.id = null;\n      node.generator = false;\n      node.async = !!isAsync;\n    }\n  }, {\n    key: \"parseMethod\",\n    value: function parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type) {\n      var inClassScope = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;\n      var oldYieldPos = this.state.yieldPos;\n      var oldAwaitPos = this.state.awaitPos;\n      this.state.yieldPos = -1;\n      this.state.awaitPos = -1;\n      this.initFunction(node, isAsync);\n      node.generator = !!isGenerator;\n      var allowModifiers = isConstructor;\n      this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));\n      this.prodParam.enter(functionFlags(isAsync, node.generator));\n      this.parseFunctionParams(node, allowModifiers);\n      this.parseFunctionBodyAndFinish(node, type, true);\n      this.prodParam.exit();\n      this.scope.exit();\n      this.state.yieldPos = oldYieldPos;\n      this.state.awaitPos = oldAwaitPos;\n      return node;\n    }\n  }, {\n    key: \"parseArrayLike\",\n    value: function parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {\n      if (isTuple) {\n        this.expectPlugin(\"recordAndTuple\");\n      }\n\n      var oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n      this.state.inFSharpPipelineDirectBody = false;\n      var node = this.startNode();\n      this.next();\n      node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);\n\n      if (canBePattern && !this.state.maybeInArrowParameters) {\n        this.toReferencedList(node.elements);\n      }\n\n      this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n      return this.finishNode(node, isTuple ? \"TupleExpression\" : \"ArrayExpression\");\n    }\n  }, {\n    key: \"parseArrowExpression\",\n    value: function parseArrowExpression(node, params, isAsync, trailingCommaPos) {\n      this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);\n      var flags = functionFlags(isAsync, false);\n\n      if (!this.match(types.bracketL) && this.prodParam.hasIn) {\n        flags |= PARAM_IN;\n      }\n\n      this.prodParam.enter(flags);\n      this.initFunction(node, isAsync);\n      var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      var oldYieldPos = this.state.yieldPos;\n      var oldAwaitPos = this.state.awaitPos;\n\n      if (params) {\n        this.state.maybeInArrowParameters = true;\n        this.setArrowFunctionParameters(node, params, trailingCommaPos);\n      }\n\n      this.state.maybeInArrowParameters = false;\n      this.state.yieldPos = -1;\n      this.state.awaitPos = -1;\n      this.parseFunctionBody(node, true);\n      this.prodParam.exit();\n      this.scope.exit();\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n      this.state.yieldPos = oldYieldPos;\n      this.state.awaitPos = oldAwaitPos;\n      return this.finishNode(node, \"ArrowFunctionExpression\");\n    }\n  }, {\n    key: \"setArrowFunctionParameters\",\n    value: function setArrowFunctionParameters(node, params, trailingCommaPos) {\n      node.params = this.toAssignableList(params, trailingCommaPos);\n    }\n  }, {\n    key: \"parseFunctionBodyAndFinish\",\n    value: function parseFunctionBodyAndFinish(node, type) {\n      var isMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n      this.parseFunctionBody(node, false, isMethod);\n      this.finishNode(node, type);\n    }\n  }, {\n    key: \"parseFunctionBody\",\n    value: function parseFunctionBody(node, allowExpression) {\n      var _this40 = this;\n\n      var isMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n      var isExpression = allowExpression && !this.match(types.braceL);\n      var oldInParameters = this.state.inParameters;\n      this.state.inParameters = false;\n\n      if (isExpression) {\n        node.body = this.parseMaybeAssign();\n        this.checkParams(node, false, allowExpression, false);\n      } else {\n        var oldStrict = this.state.strict;\n        var oldLabels = this.state.labels;\n        this.state.labels = [];\n        this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);\n        node.body = this.parseBlock(true, false, function (hasStrictModeDirective) {\n          var nonSimple = !_this40.isSimpleParamList(node.params);\n\n          if (hasStrictModeDirective && nonSimple) {\n            var errorPos = (node.kind === \"method\" || node.kind === \"constructor\") && !!node.key ? node.key.end : node.start;\n\n            _this40.raise(errorPos, ErrorMessages.IllegalLanguageModeDirective);\n          }\n\n          var strictModeChanged = !oldStrict && _this40.state.strict;\n\n          _this40.checkParams(node, !_this40.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);\n\n          if (_this40.state.strict && node.id) {\n            _this40.checkLVal(node.id, BIND_OUTSIDE, undefined, \"function name\", undefined, strictModeChanged);\n          }\n        });\n        this.prodParam.exit();\n        this.state.labels = oldLabels;\n      }\n\n      this.state.inParameters = oldInParameters;\n    }\n  }, {\n    key: \"isSimpleParamList\",\n    value: function isSimpleParamList(params) {\n      for (var i = 0, len = params.length; i < len; i++) {\n        if (params[i].type !== \"Identifier\") return false;\n      }\n\n      return true;\n    }\n  }, {\n    key: \"checkParams\",\n    value: function checkParams(node, allowDuplicates, isArrowFunction) {\n      var strictModeChanged = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;\n      var nameHash = Object.create(null);\n\n      for (var i = 0; i < node.params.length; i++) {\n        this.checkLVal(node.params[i], BIND_VAR, allowDuplicates ? null : nameHash, \"function parameter list\", undefined, strictModeChanged);\n      }\n    }\n  }, {\n    key: \"parseExprList\",\n    value: function parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {\n      var elts = [];\n      var first = true;\n\n      while (!this.eat(close)) {\n        if (first) {\n          first = false;\n        } else {\n          this.expect(types.comma);\n\n          if (this.match(close)) {\n            if (nodeForExtra) {\n              this.addExtra(nodeForExtra, \"trailingComma\", this.state.lastTokStart);\n            }\n\n            this.next();\n            break;\n          }\n        }\n\n        elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));\n      }\n\n      return elts;\n    }\n  }, {\n    key: \"parseExprListItem\",\n    value: function parseExprListItem(allowEmpty, refExpressionErrors, refNeedsArrowPos, allowPlaceholder) {\n      var elt;\n\n      if (this.match(types.comma)) {\n        if (!allowEmpty) {\n          this.raise(this.state.pos, ErrorMessages.UnexpectedToken, \",\");\n        }\n\n        elt = null;\n      } else if (this.match(types.ellipsis)) {\n        var spreadNodeStartPos = this.state.start;\n        var spreadNodeStartLoc = this.state.startLoc;\n        elt = this.parseParenItem(this.parseSpread(refExpressionErrors, refNeedsArrowPos), spreadNodeStartPos, spreadNodeStartLoc);\n      } else if (this.match(types.question)) {\n        this.expectPlugin(\"partialApplication\");\n\n        if (!allowPlaceholder) {\n          this.raise(this.state.start, ErrorMessages.UnexpectedArgumentPlaceholder);\n        }\n\n        var node = this.startNode();\n        this.next();\n        elt = this.finishNode(node, \"ArgumentPlaceholder\");\n      } else {\n        elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem, refNeedsArrowPos);\n      }\n\n      return elt;\n    }\n  }, {\n    key: \"parseIdentifier\",\n    value: function parseIdentifier(liberal) {\n      var node = this.startNode();\n      var name = this.parseIdentifierName(node.start, liberal);\n      return this.createIdentifier(node, name);\n    }\n  }, {\n    key: \"createIdentifier\",\n    value: function createIdentifier(node, name) {\n      node.name = name;\n      node.loc.identifierName = name;\n      return this.finishNode(node, \"Identifier\");\n    }\n  }, {\n    key: \"parseIdentifierName\",\n    value: function parseIdentifierName(pos, liberal) {\n      var name;\n      var _this$state2 = this.state,\n          start = _this$state2.start,\n          type = _this$state2.type;\n\n      if (type === types.name) {\n        name = this.state.value;\n      } else if (type.keyword) {\n        name = type.keyword;\n        var curContext = this.curContext();\n\n        if ((type === types._class || type === types._function) && (curContext === types$1.functionStatement || curContext === types$1.functionExpression)) {\n          this.state.context.pop();\n        }\n      } else {\n        throw this.unexpected();\n      }\n\n      if (liberal) {\n        this.state.type = types.name;\n      } else {\n        this.checkReservedWord(name, start, !!type.keyword, false);\n      }\n\n      this.next();\n      return name;\n    }\n  }, {\n    key: \"checkReservedWord\",\n    value: function checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n      if (this.prodParam.hasYield && word === \"yield\") {\n        this.raise(startLoc, ErrorMessages.YieldBindingIdentifier);\n        return;\n      }\n\n      if (word === \"await\") {\n        if (this.prodParam.hasAwait) {\n          this.raise(startLoc, ErrorMessages.AwaitBindingIdentifier);\n          return;\n        }\n\n        if (this.state.awaitPos === -1 && (this.state.maybeInAsyncArrowHead || this.isAwaitAllowed())) {\n          this.state.awaitPos = this.state.start;\n        }\n      }\n\n      if (this.scope.inClass && !this.scope.inNonArrowFunction && word === \"arguments\") {\n        this.raise(startLoc, ErrorMessages.ArgumentsDisallowedInInitializer);\n        return;\n      }\n\n      if (checkKeywords && isKeyword(word)) {\n        this.raise(startLoc, ErrorMessages.UnexpectedKeyword, word);\n        return;\n      }\n\n      var reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;\n\n      if (reservedTest(word, this.inModule)) {\n        if (!this.prodParam.hasAwait && word === \"await\") {\n          this.raise(startLoc, ErrorMessages.AwaitNotInAsyncFunction);\n        } else {\n          this.raise(startLoc, ErrorMessages.UnexpectedReservedWord, word);\n        }\n      }\n    }\n  }, {\n    key: \"isAwaitAllowed\",\n    value: function isAwaitAllowed() {\n      if (this.scope.inFunction) return this.prodParam.hasAwait;\n      if (this.options.allowAwaitOutsideFunction) return true;\n\n      if (this.hasPlugin(\"topLevelAwait\")) {\n        return this.inModule && this.prodParam.hasAwait;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"parseAwait\",\n    value: function parseAwait() {\n      var node = this.startNode();\n      this.next();\n\n      if (this.state.inParameters) {\n        this.raise(node.start, ErrorMessages.AwaitExpressionFormalParameter);\n      } else if (this.state.awaitPos === -1) {\n        this.state.awaitPos = node.start;\n      }\n\n      if (this.eat(types.star)) {\n        this.raise(node.start, ErrorMessages.ObsoleteAwaitStar);\n      }\n\n      if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {\n        if (this.hasPrecedingLineBreak() || this.match(types.plusMin) || this.match(types.parenL) || this.match(types.bracketL) || this.match(types.backQuote) || this.match(types.regexp) || this.match(types.slash) || this.hasPlugin(\"v8intrinsic\") && this.match(types.modulo)) {\n          this.ambiguousScriptDifferentAst = true;\n        } else {\n          this.sawUnambiguousESM = true;\n        }\n      }\n\n      if (!this.state.soloAwait) {\n        node.argument = this.parseMaybeUnary();\n      }\n\n      return this.finishNode(node, \"AwaitExpression\");\n    }\n  }, {\n    key: \"parseYield\",\n    value: function parseYield() {\n      var node = this.startNode();\n\n      if (this.state.inParameters) {\n        this.raise(node.start, ErrorMessages.YieldInParameter);\n      } else if (this.state.yieldPos === -1) {\n        this.state.yieldPos = node.start;\n      }\n\n      this.next();\n\n      if (this.match(types.semi) || !this.match(types.star) && !this.state.type.startsExpr || this.hasPrecedingLineBreak()) {\n        node.delegate = false;\n        node.argument = null;\n      } else {\n        node.delegate = this.eat(types.star);\n        node.argument = this.parseMaybeAssign();\n      }\n\n      return this.finishNode(node, \"YieldExpression\");\n    }\n  }, {\n    key: \"checkPipelineAtInfixOperator\",\n    value: function checkPipelineAtInfixOperator(left, leftStartPos) {\n      if (this.getPluginOption(\"pipelineOperator\", \"proposal\") === \"smart\") {\n        if (left.type === \"SequenceExpression\") {\n          this.raise(leftStartPos, ErrorMessages.PipelineHeadSequenceExpression);\n        }\n      }\n    }\n  }, {\n    key: \"parseSmartPipelineBody\",\n    value: function parseSmartPipelineBody(childExpression, startPos, startLoc) {\n      this.checkSmartPipelineBodyEarlyErrors(childExpression, startPos);\n      return this.parseSmartPipelineBodyInStyle(childExpression, startPos, startLoc);\n    }\n  }, {\n    key: \"checkSmartPipelineBodyEarlyErrors\",\n    value: function checkSmartPipelineBodyEarlyErrors(childExpression, startPos) {\n      if (this.match(types.arrow)) {\n        throw this.raise(this.state.start, ErrorMessages.PipelineBodyNoArrow);\n      } else if (childExpression.type === \"SequenceExpression\") {\n        this.raise(startPos, ErrorMessages.PipelineBodySequenceExpression);\n      }\n    }\n  }, {\n    key: \"parseSmartPipelineBodyInStyle\",\n    value: function parseSmartPipelineBodyInStyle(childExpression, startPos, startLoc) {\n      var bodyNode = this.startNodeAt(startPos, startLoc);\n      var isSimpleReference = this.isSimpleReference(childExpression);\n\n      if (isSimpleReference) {\n        bodyNode.callee = childExpression;\n      } else {\n        if (!this.topicReferenceWasUsedInCurrentTopicContext()) {\n          this.raise(startPos, ErrorMessages.PipelineTopicUnused);\n        }\n\n        bodyNode.expression = childExpression;\n      }\n\n      return this.finishNode(bodyNode, isSimpleReference ? \"PipelineBareFunction\" : \"PipelineTopicExpression\");\n    }\n  }, {\n    key: \"isSimpleReference\",\n    value: function isSimpleReference(expression) {\n      switch (expression.type) {\n        case \"MemberExpression\":\n          return !expression.computed && this.isSimpleReference(expression.object);\n\n        case \"Identifier\":\n          return true;\n\n        default:\n          return false;\n      }\n    }\n  }, {\n    key: \"withTopicPermittingContext\",\n    value: function withTopicPermittingContext(callback) {\n      var outerContextTopicState = this.state.topicContext;\n      this.state.topicContext = {\n        maxNumOfResolvableTopics: 1,\n        maxTopicIndex: null\n      };\n\n      try {\n        return callback();\n      } finally {\n        this.state.topicContext = outerContextTopicState;\n      }\n    }\n  }, {\n    key: \"withTopicForbiddingContext\",\n    value: function withTopicForbiddingContext(callback) {\n      var outerContextTopicState = this.state.topicContext;\n      this.state.topicContext = {\n        maxNumOfResolvableTopics: 0,\n        maxTopicIndex: null\n      };\n\n      try {\n        return callback();\n      } finally {\n        this.state.topicContext = outerContextTopicState;\n      }\n    }\n  }, {\n    key: \"withSoloAwaitPermittingContext\",\n    value: function withSoloAwaitPermittingContext(callback) {\n      var outerContextSoloAwaitState = this.state.soloAwait;\n      this.state.soloAwait = true;\n\n      try {\n        return callback();\n      } finally {\n        this.state.soloAwait = outerContextSoloAwaitState;\n      }\n    }\n  }, {\n    key: \"allowInAnd\",\n    value: function allowInAnd(callback) {\n      var flags = this.prodParam.currentFlags();\n      var prodParamToSet = PARAM_IN & ~flags;\n\n      if (prodParamToSet) {\n        this.prodParam.enter(flags | PARAM_IN);\n\n        try {\n          return callback();\n        } finally {\n          this.prodParam.exit();\n        }\n      }\n\n      return callback();\n    }\n  }, {\n    key: \"disallowInAnd\",\n    value: function disallowInAnd(callback) {\n      var flags = this.prodParam.currentFlags();\n      var prodParamToClear = PARAM_IN & flags;\n\n      if (prodParamToClear) {\n        this.prodParam.enter(flags & ~PARAM_IN);\n\n        try {\n          return callback();\n        } finally {\n          this.prodParam.exit();\n        }\n      }\n\n      return callback();\n    }\n  }, {\n    key: \"registerTopicReference\",\n    value: function registerTopicReference() {\n      this.state.topicContext.maxTopicIndex = 0;\n    }\n  }, {\n    key: \"primaryTopicReferenceIsAllowedInCurrentTopicContext\",\n    value: function primaryTopicReferenceIsAllowedInCurrentTopicContext() {\n      return this.state.topicContext.maxNumOfResolvableTopics >= 1;\n    }\n  }, {\n    key: \"topicReferenceWasUsedInCurrentTopicContext\",\n    value: function topicReferenceWasUsedInCurrentTopicContext() {\n      return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;\n    }\n  }, {\n    key: \"parseFSharpPipelineBody\",\n    value: function parseFSharpPipelineBody(prec) {\n      var startPos = this.state.start;\n      var startLoc = this.state.startLoc;\n      this.state.potentialArrowAt = this.state.start;\n      var oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n      this.state.inFSharpPipelineDirectBody = true;\n      var ret = this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, prec);\n      this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n      return ret;\n    }\n  }]);\n\n  return ExpressionParser;\n}(LValParser);\n\nvar loopLabel = {\n  kind: \"loop\"\n},\n    switchLabel = {\n  kind: \"switch\"\n};\nvar FUNC_NO_FLAGS = 0,\n    FUNC_STATEMENT = 1,\n    FUNC_HANGING_STATEMENT = 2,\n    FUNC_NULLABLE_ID = 4;\n\nvar StatementParser = /*#__PURE__*/function (_ExpressionParser) {\n  _inherits(StatementParser, _ExpressionParser);\n\n  var _super16 = _createSuper(StatementParser);\n\n  function StatementParser() {\n    _classCallCheck(this, StatementParser);\n\n    return _super16.apply(this, arguments);\n  }\n\n  _createClass(StatementParser, [{\n    key: \"parseTopLevel\",\n    value: function parseTopLevel(file, program) {\n      program.sourceType = this.options.sourceType;\n      program.interpreter = this.parseInterpreterDirective();\n      this.parseBlockBody(program, true, true, types.eof);\n\n      if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {\n        for (var _i = 0, _Array$from = Array.from(this.scope.undefinedExports); _i < _Array$from.length; _i++) {\n          var _Array$from$_i = _slicedToArray(_Array$from[_i], 1),\n              name = _Array$from$_i[0];\n\n          var pos = this.scope.undefinedExports.get(name);\n          this.raise(pos, ErrorMessages.ModuleExportUndefined, name);\n        }\n      }\n\n      file.program = this.finishNode(program, \"Program\");\n      file.comments = this.state.comments;\n      if (this.options.tokens) file.tokens = this.tokens;\n      return this.finishNode(file, \"File\");\n    }\n  }, {\n    key: \"stmtToDirective\",\n    value: function stmtToDirective(stmt) {\n      var expr = stmt.expression;\n      var directiveLiteral = this.startNodeAt(expr.start, expr.loc.start);\n      var directive = this.startNodeAt(stmt.start, stmt.loc.start);\n      var raw = this.input.slice(expr.start, expr.end);\n      var val = directiveLiteral.value = raw.slice(1, -1);\n      this.addExtra(directiveLiteral, \"raw\", raw);\n      this.addExtra(directiveLiteral, \"rawValue\", val);\n      directive.value = this.finishNodeAt(directiveLiteral, \"DirectiveLiteral\", expr.end, expr.loc.end);\n      return this.finishNodeAt(directive, \"Directive\", stmt.end, stmt.loc.end);\n    }\n  }, {\n    key: \"parseInterpreterDirective\",\n    value: function parseInterpreterDirective() {\n      if (!this.match(types.interpreterDirective)) {\n        return null;\n      }\n\n      var node = this.startNode();\n      node.value = this.state.value;\n      this.next();\n      return this.finishNode(node, \"InterpreterDirective\");\n    }\n  }, {\n    key: \"isLet\",\n    value: function isLet(context) {\n      if (!this.isContextual(\"let\")) {\n        return false;\n      }\n\n      var next = this.nextTokenStart();\n      var nextCh = this.input.charCodeAt(next);\n      if (nextCh === 91) return true;\n      if (context) return false;\n      if (nextCh === 123) return true;\n\n      if (isIdentifierStart(nextCh)) {\n        var pos = next + 1;\n\n        while (isIdentifierChar(this.input.charCodeAt(pos))) {\n          ++pos;\n        }\n\n        var ident = this.input.slice(next, pos);\n        if (!keywordRelationalOperator.test(ident)) return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"parseStatement\",\n    value: function parseStatement(context, topLevel) {\n      if (this.match(types.at)) {\n        this.parseDecorators(true);\n      }\n\n      return this.parseStatementContent(context, topLevel);\n    }\n  }, {\n    key: \"parseStatementContent\",\n    value: function parseStatementContent(context, topLevel) {\n      var starttype = this.state.type;\n      var node = this.startNode();\n      var kind;\n\n      if (this.isLet(context)) {\n        starttype = types._var;\n        kind = \"let\";\n      }\n\n      switch (starttype) {\n        case types._break:\n        case types._continue:\n          return this.parseBreakContinueStatement(node, starttype.keyword);\n\n        case types._debugger:\n          return this.parseDebuggerStatement(node);\n\n        case types._do:\n          return this.parseDoStatement(node);\n\n        case types._for:\n          return this.parseForStatement(node);\n\n        case types._function:\n          if (this.lookaheadCharCode() === 46) break;\n\n          if (context) {\n            if (this.state.strict) {\n              this.raise(this.state.start, ErrorMessages.StrictFunction);\n            } else if (context !== \"if\" && context !== \"label\") {\n              this.raise(this.state.start, ErrorMessages.SloppyFunction);\n            }\n          }\n\n          return this.parseFunctionStatement(node, false, !context);\n\n        case types._class:\n          if (context) this.unexpected();\n          return this.parseClass(node, true);\n\n        case types._if:\n          return this.parseIfStatement(node);\n\n        case types._return:\n          return this.parseReturnStatement(node);\n\n        case types._switch:\n          return this.parseSwitchStatement(node);\n\n        case types._throw:\n          return this.parseThrowStatement(node);\n\n        case types._try:\n          return this.parseTryStatement(node);\n\n        case types._const:\n        case types._var:\n          kind = kind || this.state.value;\n\n          if (context && kind !== \"var\") {\n            this.raise(this.state.start, ErrorMessages.UnexpectedLexicalDeclaration);\n          }\n\n          return this.parseVarStatement(node, kind);\n\n        case types._while:\n          return this.parseWhileStatement(node);\n\n        case types._with:\n          return this.parseWithStatement(node);\n\n        case types.braceL:\n          return this.parseBlock();\n\n        case types.semi:\n          return this.parseEmptyStatement(node);\n\n        case types._import:\n          {\n            var nextTokenCharCode = this.lookaheadCharCode();\n\n            if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {\n              break;\n            }\n          }\n\n        case types._export:\n          {\n            if (!this.options.allowImportExportEverywhere && !topLevel) {\n              this.raise(this.state.start, ErrorMessages.UnexpectedImportExport);\n            }\n\n            this.next();\n            var result;\n\n            if (starttype === types._import) {\n              result = this.parseImport(node);\n\n              if (result.type === \"ImportDeclaration\" && (!result.importKind || result.importKind === \"value\")) {\n                this.sawUnambiguousESM = true;\n              }\n            } else {\n              result = this.parseExport(node);\n\n              if (result.type === \"ExportNamedDeclaration\" && (!result.exportKind || result.exportKind === \"value\") || result.type === \"ExportAllDeclaration\" && (!result.exportKind || result.exportKind === \"value\") || result.type === \"ExportDefaultDeclaration\") {\n                this.sawUnambiguousESM = true;\n              }\n            }\n\n            this.assertModuleNodeAllowed(node);\n            return result;\n          }\n\n        default:\n          {\n            if (this.isAsyncFunction()) {\n              if (context) {\n                this.raise(this.state.start, ErrorMessages.AsyncFunctionInSingleStatementContext);\n              }\n\n              this.next();\n              return this.parseFunctionStatement(node, true, !context);\n            }\n          }\n      }\n\n      var maybeName = this.state.value;\n      var expr = this.parseExpression();\n\n      if (starttype === types.name && expr.type === \"Identifier\" && this.eat(types.colon)) {\n        return this.parseLabeledStatement(node, maybeName, expr, context);\n      } else {\n        return this.parseExpressionStatement(node, expr);\n      }\n    }\n  }, {\n    key: \"assertModuleNodeAllowed\",\n    value: function assertModuleNodeAllowed(node) {\n      if (!this.options.allowImportExportEverywhere && !this.inModule) {\n        this.raiseWithData(node.start, {\n          code: \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\"\n        }, ErrorMessages.ImportOutsideModule);\n      }\n    }\n  }, {\n    key: \"takeDecorators\",\n    value: function takeDecorators(node) {\n      var decorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];\n\n      if (decorators.length) {\n        node.decorators = decorators;\n        this.resetStartLocationFromNode(node, decorators[0]);\n        this.state.decoratorStack[this.state.decoratorStack.length - 1] = [];\n      }\n    }\n  }, {\n    key: \"canHaveLeadingDecorator\",\n    value: function canHaveLeadingDecorator() {\n      return this.match(types._class);\n    }\n  }, {\n    key: \"parseDecorators\",\n    value: function parseDecorators(allowExport) {\n      var currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];\n\n      while (this.match(types.at)) {\n        var decorator = this.parseDecorator();\n        currentContextDecorators.push(decorator);\n      }\n\n      if (this.match(types._export)) {\n        if (!allowExport) {\n          this.unexpected();\n        }\n\n        if (this.hasPlugin(\"decorators\") && !this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\")) {\n          this.raise(this.state.start, ErrorMessages.DecoratorExportClass);\n        }\n      } else if (!this.canHaveLeadingDecorator()) {\n        throw this.raise(this.state.start, ErrorMessages.UnexpectedLeadingDecorator);\n      }\n    }\n  }, {\n    key: \"parseDecorator\",\n    value: function parseDecorator() {\n      this.expectOnePlugin([\"decorators-legacy\", \"decorators\"]);\n      var node = this.startNode();\n      this.next();\n\n      if (this.hasPlugin(\"decorators\")) {\n        this.state.decoratorStack.push([]);\n        var startPos = this.state.start;\n        var startLoc = this.state.startLoc;\n        var expr;\n\n        if (this.eat(types.parenL)) {\n          expr = this.parseExpression();\n          this.expect(types.parenR);\n        } else {\n          expr = this.parseIdentifier(false);\n\n          while (this.eat(types.dot)) {\n            var _node11 = this.startNodeAt(startPos, startLoc);\n\n            _node11.object = expr;\n            _node11.property = this.parseIdentifier(true);\n            _node11.computed = false;\n            expr = this.finishNode(_node11, \"MemberExpression\");\n          }\n        }\n\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n        this.state.decoratorStack.pop();\n      } else {\n        node.expression = this.parseExprSubscripts();\n      }\n\n      return this.finishNode(node, \"Decorator\");\n    }\n  }, {\n    key: \"parseMaybeDecoratorArguments\",\n    value: function parseMaybeDecoratorArguments(expr) {\n      if (this.eat(types.parenL)) {\n        var node = this.startNodeAtNode(expr);\n        node.callee = expr;\n        node.arguments = this.parseCallExpressionArguments(types.parenR, false);\n        this.toReferencedList(node.arguments);\n        return this.finishNode(node, \"CallExpression\");\n      }\n\n      return expr;\n    }\n  }, {\n    key: \"parseBreakContinueStatement\",\n    value: function parseBreakContinueStatement(node, keyword) {\n      var isBreak = keyword === \"break\";\n      this.next();\n\n      if (this.isLineTerminator()) {\n        node.label = null;\n      } else {\n        node.label = this.parseIdentifier();\n        this.semicolon();\n      }\n\n      this.verifyBreakContinue(node, keyword);\n      return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\");\n    }\n  }, {\n    key: \"verifyBreakContinue\",\n    value: function verifyBreakContinue(node, keyword) {\n      var isBreak = keyword === \"break\";\n      var i;\n\n      for (i = 0; i < this.state.labels.length; ++i) {\n        var lab = this.state.labels[i];\n\n        if (node.label == null || lab.name === node.label.name) {\n          if (lab.kind != null && (isBreak || lab.kind === \"loop\")) break;\n          if (node.label && isBreak) break;\n        }\n      }\n\n      if (i === this.state.labels.length) {\n        this.raise(node.start, ErrorMessages.IllegalBreakContinue, keyword);\n      }\n    }\n  }, {\n    key: \"parseDebuggerStatement\",\n    value: function parseDebuggerStatement(node) {\n      this.next();\n      this.semicolon();\n      return this.finishNode(node, \"DebuggerStatement\");\n    }\n  }, {\n    key: \"parseHeaderExpression\",\n    value: function parseHeaderExpression() {\n      this.expect(types.parenL);\n      var val = this.parseExpression();\n      this.expect(types.parenR);\n      return val;\n    }\n  }, {\n    key: \"parseDoStatement\",\n    value: function parseDoStatement(node) {\n      var _this41 = this;\n\n      this.next();\n      this.state.labels.push(loopLabel);\n      node.body = this.withTopicForbiddingContext(function () {\n        return _this41.parseStatement(\"do\");\n      });\n      this.state.labels.pop();\n      this.expect(types._while);\n      node.test = this.parseHeaderExpression();\n      this.eat(types.semi);\n      return this.finishNode(node, \"DoWhileStatement\");\n    }\n  }, {\n    key: \"parseForStatement\",\n    value: function parseForStatement(node) {\n      this.next();\n      this.state.labels.push(loopLabel);\n      var awaitAt = -1;\n\n      if (this.isAwaitAllowed() && this.eatContextual(\"await\")) {\n        awaitAt = this.state.lastTokStart;\n      }\n\n      this.scope.enter(SCOPE_OTHER);\n      this.expect(types.parenL);\n\n      if (this.match(types.semi)) {\n        if (awaitAt > -1) {\n          this.unexpected(awaitAt);\n        }\n\n        return this.parseFor(node, null);\n      }\n\n      var isLet = this.isLet();\n\n      if (this.match(types._var) || this.match(types._const) || isLet) {\n        var _init = this.startNode();\n\n        var kind = isLet ? \"let\" : this.state.value;\n        this.next();\n        this.parseVar(_init, true, kind);\n        this.finishNode(_init, \"VariableDeclaration\");\n\n        if ((this.match(types._in) || this.isContextual(\"of\")) && _init.declarations.length === 1) {\n          return this.parseForIn(node, _init, awaitAt);\n        }\n\n        if (awaitAt > -1) {\n          this.unexpected(awaitAt);\n        }\n\n        return this.parseFor(node, _init);\n      }\n\n      var refExpressionErrors = new ExpressionErrors();\n      var init = this.parseExpression(true, refExpressionErrors);\n\n      if (this.match(types._in) || this.isContextual(\"of\")) {\n        this.toAssignable(init);\n        var description = this.isContextual(\"of\") ? \"for-of statement\" : \"for-in statement\";\n        this.checkLVal(init, undefined, undefined, description);\n        return this.parseForIn(node, init, awaitAt);\n      } else {\n        this.checkExpressionErrors(refExpressionErrors, true);\n      }\n\n      if (awaitAt > -1) {\n        this.unexpected(awaitAt);\n      }\n\n      return this.parseFor(node, init);\n    }\n  }, {\n    key: \"parseFunctionStatement\",\n    value: function parseFunctionStatement(node, isAsync, declarationPosition) {\n      this.next();\n      return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync);\n    }\n  }, {\n    key: \"parseIfStatement\",\n    value: function parseIfStatement(node) {\n      this.next();\n      node.test = this.parseHeaderExpression();\n      node.consequent = this.parseStatement(\"if\");\n      node.alternate = this.eat(types._else) ? this.parseStatement(\"if\") : null;\n      return this.finishNode(node, \"IfStatement\");\n    }\n  }, {\n    key: \"parseReturnStatement\",\n    value: function parseReturnStatement(node) {\n      if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {\n        this.raise(this.state.start, ErrorMessages.IllegalReturn);\n      }\n\n      this.next();\n\n      if (this.isLineTerminator()) {\n        node.argument = null;\n      } else {\n        node.argument = this.parseExpression();\n        this.semicolon();\n      }\n\n      return this.finishNode(node, \"ReturnStatement\");\n    }\n  }, {\n    key: \"parseSwitchStatement\",\n    value: function parseSwitchStatement(node) {\n      this.next();\n      node.discriminant = this.parseHeaderExpression();\n      var cases = node.cases = [];\n      this.expect(types.braceL);\n      this.state.labels.push(switchLabel);\n      this.scope.enter(SCOPE_OTHER);\n      var cur;\n\n      for (var sawDefault; !this.match(types.braceR);) {\n        if (this.match(types._case) || this.match(types._default)) {\n          var isCase = this.match(types._case);\n          if (cur) this.finishNode(cur, \"SwitchCase\");\n          cases.push(cur = this.startNode());\n          cur.consequent = [];\n          this.next();\n\n          if (isCase) {\n            cur.test = this.parseExpression();\n          } else {\n            if (sawDefault) {\n              this.raise(this.state.lastTokStart, ErrorMessages.MultipleDefaultsInSwitch);\n            }\n\n            sawDefault = true;\n            cur.test = null;\n          }\n\n          this.expect(types.colon);\n        } else {\n          if (cur) {\n            cur.consequent.push(this.parseStatement(null));\n          } else {\n            this.unexpected();\n          }\n        }\n      }\n\n      this.scope.exit();\n      if (cur) this.finishNode(cur, \"SwitchCase\");\n      this.next();\n      this.state.labels.pop();\n      return this.finishNode(node, \"SwitchStatement\");\n    }\n  }, {\n    key: \"parseThrowStatement\",\n    value: function parseThrowStatement(node) {\n      this.next();\n\n      if (this.hasPrecedingLineBreak()) {\n        this.raise(this.state.lastTokEnd, ErrorMessages.NewlineAfterThrow);\n      }\n\n      node.argument = this.parseExpression();\n      this.semicolon();\n      return this.finishNode(node, \"ThrowStatement\");\n    }\n  }, {\n    key: \"parseCatchClauseParam\",\n    value: function parseCatchClauseParam() {\n      var param = this.parseBindingAtom();\n      var simple = param.type === \"Identifier\";\n      this.scope.enter(simple ? SCOPE_SIMPLE_CATCH : 0);\n      this.checkLVal(param, BIND_LEXICAL, null, \"catch clause\");\n      return param;\n    }\n  }, {\n    key: \"parseTryStatement\",\n    value: function parseTryStatement(node) {\n      var _this42 = this;\n\n      this.next();\n      node.block = this.parseBlock();\n      node.handler = null;\n\n      if (this.match(types._catch)) {\n        var clause = this.startNode();\n        this.next();\n\n        if (this.match(types.parenL)) {\n          this.expect(types.parenL);\n          clause.param = this.parseCatchClauseParam();\n          this.expect(types.parenR);\n        } else {\n          clause.param = null;\n          this.scope.enter(SCOPE_OTHER);\n        }\n\n        clause.body = this.withTopicForbiddingContext(function () {\n          return _this42.parseBlock(false, false);\n        });\n        this.scope.exit();\n        node.handler = this.finishNode(clause, \"CatchClause\");\n      }\n\n      node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;\n\n      if (!node.handler && !node.finalizer) {\n        this.raise(node.start, ErrorMessages.NoCatchOrFinally);\n      }\n\n      return this.finishNode(node, \"TryStatement\");\n    }\n  }, {\n    key: \"parseVarStatement\",\n    value: function parseVarStatement(node, kind) {\n      this.next();\n      this.parseVar(node, false, kind);\n      this.semicolon();\n      return this.finishNode(node, \"VariableDeclaration\");\n    }\n  }, {\n    key: \"parseWhileStatement\",\n    value: function parseWhileStatement(node) {\n      var _this43 = this;\n\n      this.next();\n      node.test = this.parseHeaderExpression();\n      this.state.labels.push(loopLabel);\n      node.body = this.withTopicForbiddingContext(function () {\n        return _this43.parseStatement(\"while\");\n      });\n      this.state.labels.pop();\n      return this.finishNode(node, \"WhileStatement\");\n    }\n  }, {\n    key: \"parseWithStatement\",\n    value: function parseWithStatement(node) {\n      var _this44 = this;\n\n      if (this.state.strict) {\n        this.raise(this.state.start, ErrorMessages.StrictWith);\n      }\n\n      this.next();\n      node.object = this.parseHeaderExpression();\n      node.body = this.withTopicForbiddingContext(function () {\n        return _this44.parseStatement(\"with\");\n      });\n      return this.finishNode(node, \"WithStatement\");\n    }\n  }, {\n    key: \"parseEmptyStatement\",\n    value: function parseEmptyStatement(node) {\n      this.next();\n      return this.finishNode(node, \"EmptyStatement\");\n    }\n  }, {\n    key: \"parseLabeledStatement\",\n    value: function parseLabeledStatement(node, maybeName, expr, context) {\n      for (var _i2 = 0, _this$state$labels = this.state.labels; _i2 < _this$state$labels.length; _i2++) {\n        var label = _this$state$labels[_i2];\n\n        if (label.name === maybeName) {\n          this.raise(expr.start, ErrorMessages.LabelRedeclaration, maybeName);\n        }\n      }\n\n      var kind = this.state.type.isLoop ? \"loop\" : this.match(types._switch) ? \"switch\" : null;\n\n      for (var i = this.state.labels.length - 1; i >= 0; i--) {\n        var _label = this.state.labels[i];\n\n        if (_label.statementStart === node.start) {\n          _label.statementStart = this.state.start;\n          _label.kind = kind;\n        } else {\n          break;\n        }\n      }\n\n      this.state.labels.push({\n        name: maybeName,\n        kind: kind,\n        statementStart: this.state.start\n      });\n      node.body = this.parseStatement(context ? context.indexOf(\"label\") === -1 ? context + \"label\" : context : \"label\");\n      this.state.labels.pop();\n      node.label = expr;\n      return this.finishNode(node, \"LabeledStatement\");\n    }\n  }, {\n    key: \"parseExpressionStatement\",\n    value: function parseExpressionStatement(node, expr) {\n      node.expression = expr;\n      this.semicolon();\n      return this.finishNode(node, \"ExpressionStatement\");\n    }\n  }, {\n    key: \"parseBlock\",\n    value: function parseBlock() {\n      var allowDirectives = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n      var createNewLexicalScope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n      var afterBlockParse = arguments.length > 2 ? arguments[2] : undefined;\n      var node = this.startNode();\n      this.expect(types.braceL);\n\n      if (createNewLexicalScope) {\n        this.scope.enter(SCOPE_OTHER);\n      }\n\n      this.parseBlockBody(node, allowDirectives, false, types.braceR, afterBlockParse);\n\n      if (createNewLexicalScope) {\n        this.scope.exit();\n      }\n\n      return this.finishNode(node, \"BlockStatement\");\n    }\n  }, {\n    key: \"isValidDirective\",\n    value: function isValidDirective(stmt) {\n      return stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"StringLiteral\" && !stmt.expression.extra.parenthesized;\n    }\n  }, {\n    key: \"parseBlockBody\",\n    value: function parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {\n      var body = node.body = [];\n      var directives = node.directives = [];\n      this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);\n    }\n  }, {\n    key: \"parseBlockOrModuleBlockBody\",\n    value: function parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {\n      var octalPositions = [];\n      var oldStrict = this.state.strict;\n      var hasStrictModeDirective = false;\n      var parsedNonDirective = false;\n\n      while (!this.match(end)) {\n        if (!parsedNonDirective && this.state.octalPositions.length) {\n          octalPositions.push.apply(octalPositions, _toConsumableArray(this.state.octalPositions));\n        }\n\n        var stmt = this.parseStatement(null, topLevel);\n\n        if (directives && !parsedNonDirective && this.isValidDirective(stmt)) {\n          var directive = this.stmtToDirective(stmt);\n          directives.push(directive);\n\n          if (!hasStrictModeDirective && directive.value.value === \"use strict\") {\n            hasStrictModeDirective = true;\n            this.setStrict(true);\n          }\n\n          continue;\n        }\n\n        parsedNonDirective = true;\n        body.push(stmt);\n      }\n\n      if (this.state.strict && octalPositions.length) {\n        for (var _i3 = 0; _i3 < octalPositions.length; _i3++) {\n          var pos = octalPositions[_i3];\n          this.raise(pos, ErrorMessages.StrictOctalLiteral);\n        }\n      }\n\n      if (afterBlockParse) {\n        afterBlockParse.call(this, hasStrictModeDirective);\n      }\n\n      if (!oldStrict) {\n        this.setStrict(false);\n      }\n\n      this.next();\n    }\n  }, {\n    key: \"parseFor\",\n    value: function parseFor(node, init) {\n      var _this45 = this;\n\n      node.init = init;\n      this.expect(types.semi);\n      node.test = this.match(types.semi) ? null : this.parseExpression();\n      this.expect(types.semi);\n      node.update = this.match(types.parenR) ? null : this.parseExpression();\n      this.expect(types.parenR);\n      node.body = this.withTopicForbiddingContext(function () {\n        return _this45.parseStatement(\"for\");\n      });\n      this.scope.exit();\n      this.state.labels.pop();\n      return this.finishNode(node, \"ForStatement\");\n    }\n  }, {\n    key: \"parseForIn\",\n    value: function parseForIn(node, init, awaitAt) {\n      var _this46 = this;\n\n      var isForIn = this.match(types._in);\n      this.next();\n\n      if (isForIn) {\n        if (awaitAt > -1) this.unexpected(awaitAt);\n      } else {\n        node.await = awaitAt > -1;\n      }\n\n      if (init.type === \"VariableDeclaration\" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== \"var\" || init.declarations[0].id.type !== \"Identifier\")) {\n        this.raise(init.start, ErrorMessages.ForInOfLoopInitializer, isForIn ? \"for-in\" : \"for-of\");\n      } else if (init.type === \"AssignmentPattern\") {\n        this.raise(init.start, ErrorMessages.InvalidLhs, \"for-loop\");\n      }\n\n      node.left = init;\n      node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();\n      this.expect(types.parenR);\n      node.body = this.withTopicForbiddingContext(function () {\n        return _this46.parseStatement(\"for\");\n      });\n      this.scope.exit();\n      this.state.labels.pop();\n      return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\");\n    }\n  }, {\n    key: \"parseVar\",\n    value: function parseVar(node, isFor, kind) {\n      var declarations = node.declarations = [];\n      var isTypescript = this.hasPlugin(\"typescript\");\n      node.kind = kind;\n\n      for (;;) {\n        var decl = this.startNode();\n        this.parseVarId(decl, kind);\n\n        if (this.eat(types.eq)) {\n          decl.init = isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();\n        } else {\n          if (kind === \"const\" && !(this.match(types._in) || this.isContextual(\"of\"))) {\n            if (!isTypescript) {\n              this.unexpected();\n            }\n          } else if (decl.id.type !== \"Identifier\" && !(isFor && (this.match(types._in) || this.isContextual(\"of\")))) {\n            this.raise(this.state.lastTokEnd, ErrorMessages.DeclarationMissingInitializer, \"Complex binding patterns\");\n          }\n\n          decl.init = null;\n        }\n\n        declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n        if (!this.eat(types.comma)) break;\n      }\n\n      return node;\n    }\n  }, {\n    key: \"parseVarId\",\n    value: function parseVarId(decl, kind) {\n      decl.id = this.parseBindingAtom();\n      this.checkLVal(decl.id, kind === \"var\" ? BIND_VAR : BIND_LEXICAL, undefined, \"variable declaration\", kind !== \"var\");\n    }\n  }, {\n    key: \"parseFunction\",\n    value: function parseFunction(node) {\n      var _this47 = this;\n\n      var statement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : FUNC_NO_FLAGS;\n      var isAsync = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n      var isStatement = statement & FUNC_STATEMENT;\n      var isHangingStatement = statement & FUNC_HANGING_STATEMENT;\n      var requireId = !!isStatement && !(statement & FUNC_NULLABLE_ID);\n      this.initFunction(node, isAsync);\n\n      if (this.match(types.star) && isHangingStatement) {\n        this.raise(this.state.start, ErrorMessages.GeneratorInSingleStatementContext);\n      }\n\n      node.generator = this.eat(types.star);\n\n      if (isStatement) {\n        node.id = this.parseFunctionId(requireId);\n      }\n\n      var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      var oldYieldPos = this.state.yieldPos;\n      var oldAwaitPos = this.state.awaitPos;\n      this.state.maybeInArrowParameters = false;\n      this.state.yieldPos = -1;\n      this.state.awaitPos = -1;\n      this.scope.enter(SCOPE_FUNCTION);\n      this.prodParam.enter(functionFlags(isAsync, node.generator));\n\n      if (!isStatement) {\n        node.id = this.parseFunctionId();\n      }\n\n      this.parseFunctionParams(node);\n      this.withTopicForbiddingContext(function () {\n        _this47.parseFunctionBodyAndFinish(node, isStatement ? \"FunctionDeclaration\" : \"FunctionExpression\");\n      });\n      this.prodParam.exit();\n      this.scope.exit();\n\n      if (isStatement && !isHangingStatement) {\n        this.registerFunctionStatementId(node);\n      }\n\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n      this.state.yieldPos = oldYieldPos;\n      this.state.awaitPos = oldAwaitPos;\n      return node;\n    }\n  }, {\n    key: \"parseFunctionId\",\n    value: function parseFunctionId(requireId) {\n      return requireId || this.match(types.name) ? this.parseIdentifier() : null;\n    }\n  }, {\n    key: \"parseFunctionParams\",\n    value: function parseFunctionParams(node, allowModifiers) {\n      var oldInParameters = this.state.inParameters;\n      this.state.inParameters = true;\n      this.expect(types.parenL);\n      node.params = this.parseBindingList(types.parenR, 41, false, allowModifiers);\n      this.state.inParameters = oldInParameters;\n      this.checkYieldAwaitInDefaultParams();\n    }\n  }, {\n    key: \"registerFunctionStatementId\",\n    value: function registerFunctionStatementId(node) {\n      if (!node.id) return;\n      this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.start);\n    }\n  }, {\n    key: \"parseClass\",\n    value: function parseClass(node, isStatement, optionalId) {\n      this.next();\n      this.takeDecorators(node);\n      var oldStrict = this.state.strict;\n      this.state.strict = true;\n      this.parseClassId(node, isStatement, optionalId);\n      this.parseClassSuper(node);\n      node.body = this.parseClassBody(!!node.superClass, oldStrict);\n      return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\");\n    }\n  }, {\n    key: \"isClassProperty\",\n    value: function isClassProperty() {\n      return this.match(types.eq) || this.match(types.semi) || this.match(types.braceR);\n    }\n  }, {\n    key: \"isClassMethod\",\n    value: function isClassMethod() {\n      return this.match(types.parenL);\n    }\n  }, {\n    key: \"isNonstaticConstructor\",\n    value: function isNonstaticConstructor(method) {\n      return !method.computed && !method.static && (method.key.name === \"constructor\" || method.key.value === \"constructor\");\n    }\n  }, {\n    key: \"parseClassBody\",\n    value: function parseClassBody(constructorAllowsSuper, oldStrict) {\n      var _this48 = this;\n\n      this.classScope.enter();\n      var state = {\n        hadConstructor: false\n      };\n      var decorators = [];\n      var classBody = this.startNode();\n      classBody.body = [];\n      this.expect(types.braceL);\n      this.withTopicForbiddingContext(function () {\n        while (!_this48.match(types.braceR)) {\n          if (_this48.eat(types.semi)) {\n            if (decorators.length > 0) {\n              throw _this48.raise(_this48.state.lastTokEnd, ErrorMessages.DecoratorSemicolon);\n            }\n\n            continue;\n          }\n\n          if (_this48.match(types.at)) {\n            decorators.push(_this48.parseDecorator());\n            continue;\n          }\n\n          var member = _this48.startNode();\n\n          if (decorators.length) {\n            member.decorators = decorators;\n\n            _this48.resetStartLocationFromNode(member, decorators[0]);\n\n            decorators = [];\n          }\n\n          _this48.parseClassMember(classBody, member, state, constructorAllowsSuper);\n\n          if (member.kind === \"constructor\" && member.decorators && member.decorators.length > 0) {\n            _this48.raise(member.start, ErrorMessages.DecoratorConstructor);\n          }\n        }\n      });\n      this.state.strict = oldStrict;\n      this.next();\n\n      if (decorators.length) {\n        throw this.raise(this.state.start, ErrorMessages.TrailingDecorator);\n      }\n\n      this.classScope.exit();\n      return this.finishNode(classBody, \"ClassBody\");\n    }\n  }, {\n    key: \"parseClassMemberFromModifier\",\n    value: function parseClassMemberFromModifier(classBody, member) {\n      var key = this.parseIdentifier(true);\n\n      if (this.isClassMethod()) {\n        var method = member;\n        method.kind = \"method\";\n        method.computed = false;\n        method.key = key;\n        method.static = false;\n        this.pushClassMethod(classBody, method, false, false, false, false);\n        return true;\n      } else if (this.isClassProperty()) {\n        var prop = member;\n        prop.computed = false;\n        prop.key = key;\n        prop.static = false;\n        classBody.body.push(this.parseClassProperty(prop));\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"parseClassMember\",\n    value: function parseClassMember(classBody, member, state, constructorAllowsSuper) {\n      var isStatic = this.isContextual(\"static\");\n\n      if (isStatic && this.parseClassMemberFromModifier(classBody, member)) {\n        return;\n      }\n\n      this.parseClassMemberWithIsStatic(classBody, member, state, isStatic, constructorAllowsSuper);\n    }\n  }, {\n    key: \"parseClassMemberWithIsStatic\",\n    value: function parseClassMemberWithIsStatic(classBody, member, state, isStatic, constructorAllowsSuper) {\n      var publicMethod = member;\n      var privateMethod = member;\n      var publicProp = member;\n      var privateProp = member;\n      var method = publicMethod;\n      var publicMember = publicMethod;\n      member.static = isStatic;\n\n      if (this.eat(types.star)) {\n        method.kind = \"method\";\n        this.parseClassElementName(method);\n\n        if (method.key.type === \"PrivateName\") {\n          this.pushClassPrivateMethod(classBody, privateMethod, true, false);\n          return;\n        }\n\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(publicMethod.key.start, ErrorMessages.ConstructorIsGenerator);\n        }\n\n        this.pushClassMethod(classBody, publicMethod, true, false, false, false);\n        return;\n      }\n\n      var containsEsc = this.state.containsEsc;\n      var key = this.parseClassElementName(member);\n      var isPrivate = key.type === \"PrivateName\";\n      var isSimple = key.type === \"Identifier\";\n      var maybeQuestionTokenStart = this.state.start;\n      this.parsePostMemberNameModifiers(publicMember);\n\n      if (this.isClassMethod()) {\n        method.kind = \"method\";\n\n        if (isPrivate) {\n          this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n          return;\n        }\n\n        var isConstructor = this.isNonstaticConstructor(publicMethod);\n        var allowsDirectSuper = false;\n\n        if (isConstructor) {\n          publicMethod.kind = \"constructor\";\n\n          if (state.hadConstructor && !this.hasPlugin(\"typescript\")) {\n            this.raise(key.start, ErrorMessages.DuplicateConstructor);\n          }\n\n          state.hadConstructor = true;\n          allowsDirectSuper = constructorAllowsSuper;\n        }\n\n        this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);\n      } else if (this.isClassProperty()) {\n        if (isPrivate) {\n          this.pushClassPrivateProperty(classBody, privateProp);\n        } else {\n          this.pushClassProperty(classBody, publicProp);\n        }\n      } else if (isSimple && key.name === \"async\" && !containsEsc && !this.isLineTerminator()) {\n        var isGenerator = this.eat(types.star);\n\n        if (publicMember.optional) {\n          this.unexpected(maybeQuestionTokenStart);\n        }\n\n        method.kind = \"method\";\n        this.parseClassElementName(method);\n        this.parsePostMemberNameModifiers(publicMember);\n\n        if (method.key.type === \"PrivateName\") {\n          this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);\n        } else {\n          if (this.isNonstaticConstructor(publicMethod)) {\n            this.raise(publicMethod.key.start, ErrorMessages.ConstructorIsAsync);\n          }\n\n          this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);\n        }\n      } else if (isSimple && (key.name === \"get\" || key.name === \"set\") && !containsEsc && !(this.match(types.star) && this.isLineTerminator())) {\n        method.kind = key.name;\n        this.parseClassElementName(publicMethod);\n\n        if (method.key.type === \"PrivateName\") {\n          this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n        } else {\n          if (this.isNonstaticConstructor(publicMethod)) {\n            this.raise(publicMethod.key.start, ErrorMessages.ConstructorIsAccessor);\n          }\n\n          this.pushClassMethod(classBody, publicMethod, false, false, false, false);\n        }\n\n        this.checkGetterSetterParams(publicMethod);\n      } else if (this.isLineTerminator()) {\n        if (isPrivate) {\n          this.pushClassPrivateProperty(classBody, privateProp);\n        } else {\n          this.pushClassProperty(classBody, publicProp);\n        }\n      } else {\n        this.unexpected();\n      }\n    }\n  }, {\n    key: \"parseClassElementName\",\n    value: function parseClassElementName(member) {\n      var key = this.parsePropertyName(member, true);\n\n      if (!member.computed && member.static && (key.name === \"prototype\" || key.value === \"prototype\")) {\n        this.raise(key.start, ErrorMessages.StaticPrototype);\n      }\n\n      if (key.type === \"PrivateName\" && key.id.name === \"constructor\") {\n        this.raise(key.start, ErrorMessages.ConstructorClassPrivateField);\n      }\n\n      return key;\n    }\n  }, {\n    key: \"pushClassProperty\",\n    value: function pushClassProperty(classBody, prop) {\n      if (!prop.computed && (prop.key.name === \"constructor\" || prop.key.value === \"constructor\")) {\n        this.raise(prop.key.start, ErrorMessages.ConstructorClassField);\n      }\n\n      classBody.body.push(this.parseClassProperty(prop));\n    }\n  }, {\n    key: \"pushClassPrivateProperty\",\n    value: function pushClassPrivateProperty(classBody, prop) {\n      this.expectPlugin(\"classPrivateProperties\", prop.key.start);\n      var node = this.parseClassPrivateProperty(prop);\n      classBody.body.push(node);\n      this.classScope.declarePrivateName(node.key.id.name, CLASS_ELEMENT_OTHER, node.key.start);\n    }\n  }, {\n    key: \"pushClassMethod\",\n    value: function pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n      classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, \"ClassMethod\", true));\n    }\n  }, {\n    key: \"pushClassPrivateMethod\",\n    value: function pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n      this.expectPlugin(\"classPrivateMethods\", method.key.start);\n      var node = this.parseMethod(method, isGenerator, isAsync, false, false, \"ClassPrivateMethod\", true);\n      classBody.body.push(node);\n      var kind = node.kind === \"get\" ? node.static ? CLASS_ELEMENT_STATIC_GETTER : CLASS_ELEMENT_INSTANCE_GETTER : node.kind === \"set\" ? node.static ? CLASS_ELEMENT_STATIC_SETTER : CLASS_ELEMENT_INSTANCE_SETTER : CLASS_ELEMENT_OTHER;\n      this.classScope.declarePrivateName(node.key.id.name, kind, node.key.start);\n    }\n  }, {\n    key: \"parsePostMemberNameModifiers\",\n    value: function parsePostMemberNameModifiers(methodOrProp) {}\n  }, {\n    key: \"parseClassPrivateProperty\",\n    value: function parseClassPrivateProperty(node) {\n      this.scope.enter(SCOPE_CLASS | SCOPE_SUPER);\n      this.prodParam.enter(PARAM);\n      node.value = this.eat(types.eq) ? this.parseMaybeAssignAllowIn() : null;\n      this.semicolon();\n      this.prodParam.exit();\n      this.scope.exit();\n      return this.finishNode(node, \"ClassPrivateProperty\");\n    }\n  }, {\n    key: \"parseClassProperty\",\n    value: function parseClassProperty(node) {\n      if (!node.typeAnnotation) {\n        this.expectPlugin(\"classProperties\");\n      }\n\n      this.scope.enter(SCOPE_CLASS | SCOPE_SUPER);\n      this.prodParam.enter(PARAM);\n\n      if (this.match(types.eq)) {\n        this.expectPlugin(\"classProperties\");\n        this.next();\n        node.value = this.parseMaybeAssignAllowIn();\n      } else {\n        node.value = null;\n      }\n\n      this.semicolon();\n      this.prodParam.exit();\n      this.scope.exit();\n      return this.finishNode(node, \"ClassProperty\");\n    }\n  }, {\n    key: \"parseClassId\",\n    value: function parseClassId(node, isStatement, optionalId) {\n      var bindingType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : BIND_CLASS;\n\n      if (this.match(types.name)) {\n        node.id = this.parseIdentifier();\n\n        if (isStatement) {\n          this.checkLVal(node.id, bindingType, undefined, \"class name\");\n        }\n      } else {\n        if (optionalId || !isStatement) {\n          node.id = null;\n        } else {\n          this.unexpected(null, ErrorMessages.MissingClassName);\n        }\n      }\n    }\n  }, {\n    key: \"parseClassSuper\",\n    value: function parseClassSuper(node) {\n      node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;\n    }\n  }, {\n    key: \"parseExport\",\n    value: function parseExport(node) {\n      var hasDefault = this.maybeParseExportDefaultSpecifier(node);\n      var parseAfterDefault = !hasDefault || this.eat(types.comma);\n      var hasStar = parseAfterDefault && this.eatExportStar(node);\n      var hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);\n      var parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(types.comma));\n      var isFromRequired = hasDefault || hasStar;\n\n      if (hasStar && !hasNamespace) {\n        if (hasDefault) this.unexpected();\n        this.parseExportFrom(node, true);\n        return this.finishNode(node, \"ExportAllDeclaration\");\n      }\n\n      var hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);\n\n      if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers || hasNamespace && parseAfterNamespace && !hasSpecifiers) {\n        throw this.unexpected(null, types.braceL);\n      }\n\n      var hasDeclaration;\n\n      if (isFromRequired || hasSpecifiers) {\n        hasDeclaration = false;\n        this.parseExportFrom(node, isFromRequired);\n      } else {\n        hasDeclaration = this.maybeParseExportDeclaration(node);\n      }\n\n      if (isFromRequired || hasSpecifiers || hasDeclaration) {\n        this.checkExport(node, true, false, !!node.source);\n        return this.finishNode(node, \"ExportNamedDeclaration\");\n      }\n\n      if (this.eat(types._default)) {\n        node.declaration = this.parseExportDefaultExpression();\n        this.checkExport(node, true, true);\n        return this.finishNode(node, \"ExportDefaultDeclaration\");\n      }\n\n      throw this.unexpected(null, types.braceL);\n    }\n  }, {\n    key: \"eatExportStar\",\n    value: function eatExportStar(node) {\n      return this.eat(types.star);\n    }\n  }, {\n    key: \"maybeParseExportDefaultSpecifier\",\n    value: function maybeParseExportDefaultSpecifier(node) {\n      if (this.isExportDefaultSpecifier()) {\n        this.expectPlugin(\"exportDefaultFrom\");\n        var specifier = this.startNode();\n        specifier.exported = this.parseIdentifier(true);\n        node.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"maybeParseExportNamespaceSpecifier\",\n    value: function maybeParseExportNamespaceSpecifier(node) {\n      if (this.isContextual(\"as\")) {\n        if (!node.specifiers) node.specifiers = [];\n        var specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc);\n        this.next();\n        specifier.exported = this.parseIdentifier(true);\n        node.specifiers.push(this.finishNode(specifier, \"ExportNamespaceSpecifier\"));\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"maybeParseExportNamedSpecifiers\",\n    value: function maybeParseExportNamedSpecifiers(node) {\n      if (this.match(types.braceL)) {\n        var _node$specifiers2;\n\n        if (!node.specifiers) node.specifiers = [];\n\n        (_node$specifiers2 = node.specifiers).push.apply(_node$specifiers2, _toConsumableArray(this.parseExportSpecifiers()));\n\n        node.source = null;\n        node.declaration = null;\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"maybeParseExportDeclaration\",\n    value: function maybeParseExportDeclaration(node) {\n      if (this.shouldParseExportDeclaration()) {\n        node.specifiers = [];\n        node.source = null;\n        node.declaration = this.parseExportDeclaration(node);\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"isAsyncFunction\",\n    value: function isAsyncFunction() {\n      if (!this.isContextual(\"async\")) return false;\n      var next = this.nextTokenStart();\n      return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, \"function\");\n    }\n  }, {\n    key: \"parseExportDefaultExpression\",\n    value: function parseExportDefaultExpression() {\n      var expr = this.startNode();\n      var isAsync = this.isAsyncFunction();\n\n      if (this.match(types._function) || isAsync) {\n        this.next();\n\n        if (isAsync) {\n          this.next();\n        }\n\n        return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync);\n      } else if (this.match(types._class)) {\n        return this.parseClass(expr, true, true);\n      } else if (this.match(types.at)) {\n        if (this.hasPlugin(\"decorators\") && this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\")) {\n          this.raise(this.state.start, ErrorMessages.DecoratorBeforeExport);\n        }\n\n        this.parseDecorators(false);\n        return this.parseClass(expr, true, true);\n      } else if (this.match(types._const) || this.match(types._var) || this.isLet()) {\n        throw this.raise(this.state.start, ErrorMessages.UnsupportedDefaultExport);\n      } else {\n        var res = this.parseMaybeAssignAllowIn();\n        this.semicolon();\n        return res;\n      }\n    }\n  }, {\n    key: \"parseExportDeclaration\",\n    value: function parseExportDeclaration(node) {\n      return this.parseStatement(null);\n    }\n  }, {\n    key: \"isExportDefaultSpecifier\",\n    value: function isExportDefaultSpecifier() {\n      if (this.match(types.name)) {\n        var value = this.state.value;\n\n        if (value === \"async\" && !this.state.containsEsc || value === \"let\") {\n          return false;\n        }\n\n        if ((value === \"type\" || value === \"interface\") && !this.state.containsEsc) {\n          var l = this.lookahead();\n\n          if (l.type === types.name && l.value !== \"from\" || l.type === types.braceL) {\n            this.expectOnePlugin([\"flow\", \"typescript\"]);\n            return false;\n          }\n        }\n      } else if (!this.match(types._default)) {\n        return false;\n      }\n\n      var next = this.nextTokenStart();\n      var hasFrom = this.isUnparsedContextual(next, \"from\");\n\n      if (this.input.charCodeAt(next) === 44 || this.match(types.name) && hasFrom) {\n        return true;\n      }\n\n      if (this.match(types._default) && hasFrom) {\n        var nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));\n        return nextAfterFrom === 34 || nextAfterFrom === 39;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"parseExportFrom\",\n    value: function parseExportFrom(node, expect) {\n      if (this.eatContextual(\"from\")) {\n        node.source = this.parseImportSource();\n        this.checkExport(node);\n      } else {\n        if (expect) {\n          this.unexpected();\n        } else {\n          node.source = null;\n        }\n      }\n\n      this.semicolon();\n    }\n  }, {\n    key: \"shouldParseExportDeclaration\",\n    value: function shouldParseExportDeclaration() {\n      if (this.match(types.at)) {\n        this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n\n        if (this.hasPlugin(\"decorators\")) {\n          if (this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\")) {\n            this.unexpected(this.state.start, ErrorMessages.DecoratorBeforeExport);\n          } else {\n            return true;\n          }\n        }\n      }\n\n      return this.state.type.keyword === \"var\" || this.state.type.keyword === \"const\" || this.state.type.keyword === \"function\" || this.state.type.keyword === \"class\" || this.isLet() || this.isAsyncFunction();\n    }\n  }, {\n    key: \"checkExport\",\n    value: function checkExport(node, checkNames, isDefault, isFrom) {\n      if (checkNames) {\n        if (isDefault) {\n          this.checkDuplicateExports(node, \"default\");\n\n          if (this.hasPlugin(\"exportDefaultFrom\")) {\n            var _declaration$extra;\n\n            var declaration = node.declaration;\n\n            if (declaration.type === \"Identifier\" && declaration.name === \"from\" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) == null ? void 0 : _declaration$extra.parenthesized)) {\n              this.raise(declaration.start, ErrorMessages.ExportDefaultFromAsIdentifier);\n            }\n          }\n        } else if (node.specifiers && node.specifiers.length) {\n          for (var _i4 = 0, _node$specifiers = node.specifiers; _i4 < _node$specifiers.length; _i4++) {\n            var specifier = _node$specifiers[_i4];\n            this.checkDuplicateExports(specifier, specifier.exported.name);\n\n            if (!isFrom && specifier.local) {\n              this.checkReservedWord(specifier.local.name, specifier.local.start, true, false);\n              this.scope.checkLocalExport(specifier.local);\n            }\n          }\n        } else if (node.declaration) {\n          if (node.declaration.type === \"FunctionDeclaration\" || node.declaration.type === \"ClassDeclaration\") {\n            var id = node.declaration.id;\n            if (!id) throw new Error(\"Assertion failure\");\n            this.checkDuplicateExports(node, id.name);\n          } else if (node.declaration.type === \"VariableDeclaration\") {\n            for (var _i5 = 0, _node$declaration$dec = node.declaration.declarations; _i5 < _node$declaration$dec.length; _i5++) {\n              var _declaration = _node$declaration$dec[_i5];\n              this.checkDeclaration(_declaration.id);\n            }\n          }\n        }\n      }\n\n      var currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];\n\n      if (currentContextDecorators.length) {\n        throw this.raise(node.start, ErrorMessages.UnsupportedDecoratorExport);\n      }\n    }\n  }, {\n    key: \"checkDeclaration\",\n    value: function checkDeclaration(node) {\n      if (node.type === \"Identifier\") {\n        this.checkDuplicateExports(node, node.name);\n      } else if (node.type === \"ObjectPattern\") {\n        for (var _i6 = 0, _node$properties = node.properties; _i6 < _node$properties.length; _i6++) {\n          var prop = _node$properties[_i6];\n          this.checkDeclaration(prop);\n        }\n      } else if (node.type === \"ArrayPattern\") {\n        for (var _i7 = 0, _node$elements = node.elements; _i7 < _node$elements.length; _i7++) {\n          var elem = _node$elements[_i7];\n\n          if (elem) {\n            this.checkDeclaration(elem);\n          }\n        }\n      } else if (node.type === \"ObjectProperty\") {\n        this.checkDeclaration(node.value);\n      } else if (node.type === \"RestElement\") {\n        this.checkDeclaration(node.argument);\n      } else if (node.type === \"AssignmentPattern\") {\n        this.checkDeclaration(node.left);\n      }\n    }\n  }, {\n    key: \"checkDuplicateExports\",\n    value: function checkDuplicateExports(node, name) {\n      if (this.state.exportedIdentifiers.indexOf(name) > -1) {\n        this.raise(node.start, name === \"default\" ? ErrorMessages.DuplicateDefaultExport : ErrorMessages.DuplicateExport, name);\n      }\n\n      this.state.exportedIdentifiers.push(name);\n    }\n  }, {\n    key: \"parseExportSpecifiers\",\n    value: function parseExportSpecifiers() {\n      var nodes = [];\n      var first = true;\n      this.expect(types.braceL);\n\n      while (!this.eat(types.braceR)) {\n        if (first) {\n          first = false;\n        } else {\n          this.expect(types.comma);\n          if (this.eat(types.braceR)) break;\n        }\n\n        var node = this.startNode();\n        node.local = this.parseIdentifier(true);\n        node.exported = this.eatContextual(\"as\") ? this.parseIdentifier(true) : node.local.__clone();\n        nodes.push(this.finishNode(node, \"ExportSpecifier\"));\n      }\n\n      return nodes;\n    }\n  }, {\n    key: \"parseImport\",\n    value: function parseImport(node) {\n      node.specifiers = [];\n\n      if (!this.match(types.string)) {\n        var hasDefault = this.maybeParseDefaultImportSpecifier(node);\n        var parseNext = !hasDefault || this.eat(types.comma);\n        var hasStar = parseNext && this.maybeParseStarImportSpecifier(node);\n        if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);\n        this.expectContextual(\"from\");\n      }\n\n      node.source = this.parseImportSource();\n      var attributes = this.maybeParseModuleAttributes();\n\n      if (attributes) {\n        node.attributes = attributes;\n      }\n\n      this.semicolon();\n      return this.finishNode(node, \"ImportDeclaration\");\n    }\n  }, {\n    key: \"parseImportSource\",\n    value: function parseImportSource() {\n      if (!this.match(types.string)) this.unexpected();\n      return this.parseExprAtom();\n    }\n  }, {\n    key: \"shouldParseDefaultImport\",\n    value: function shouldParseDefaultImport(node) {\n      return this.match(types.name);\n    }\n  }, {\n    key: \"parseImportSpecifierLocal\",\n    value: function parseImportSpecifierLocal(node, specifier, type, contextDescription) {\n      specifier.local = this.parseIdentifier();\n      this.checkLVal(specifier.local, BIND_LEXICAL, undefined, contextDescription);\n      node.specifiers.push(this.finishNode(specifier, type));\n    }\n  }, {\n    key: \"maybeParseModuleAttributes\",\n    value: function maybeParseModuleAttributes() {\n      if (this.match(types._with) && !this.hasPrecedingLineBreak()) {\n        this.expectPlugin(\"moduleAttributes\");\n        this.next();\n      } else {\n        if (this.hasPlugin(\"moduleAttributes\")) return [];\n        return null;\n      }\n\n      var attrs = [];\n      var attributes = new Set();\n\n      do {\n        var node = this.startNode();\n        node.key = this.parseIdentifier(true);\n\n        if (node.key.name !== \"type\") {\n          this.raise(node.key.start, ErrorMessages.ModuleAttributeDifferentFromType, node.key.name);\n        }\n\n        if (attributes.has(node.key.name)) {\n          this.raise(node.key.start, ErrorMessages.ModuleAttributesWithDuplicateKeys, node.key.name);\n        }\n\n        attributes.add(node.key.name);\n        this.expect(types.colon);\n\n        if (!this.match(types.string)) {\n          throw this.unexpected(this.state.start, ErrorMessages.ModuleAttributeInvalidValue);\n        }\n\n        node.value = this.parseLiteral(this.state.value, \"StringLiteral\");\n        this.finishNode(node, \"ImportAttribute\");\n        attrs.push(node);\n      } while (this.eat(types.comma));\n\n      return attrs;\n    }\n  }, {\n    key: \"maybeParseDefaultImportSpecifier\",\n    value: function maybeParseDefaultImportSpecifier(node) {\n      if (this.shouldParseDefaultImport(node)) {\n        this.parseImportSpecifierLocal(node, this.startNode(), \"ImportDefaultSpecifier\", \"default import specifier\");\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"maybeParseStarImportSpecifier\",\n    value: function maybeParseStarImportSpecifier(node) {\n      if (this.match(types.star)) {\n        var specifier = this.startNode();\n        this.next();\n        this.expectContextual(\"as\");\n        this.parseImportSpecifierLocal(node, specifier, \"ImportNamespaceSpecifier\", \"import namespace specifier\");\n        return true;\n      }\n\n      return false;\n    }\n  }, {\n    key: \"parseNamedImportSpecifiers\",\n    value: function parseNamedImportSpecifiers(node) {\n      var first = true;\n      this.expect(types.braceL);\n\n      while (!this.eat(types.braceR)) {\n        if (first) {\n          first = false;\n        } else {\n          if (this.eat(types.colon)) {\n            throw this.raise(this.state.start, ErrorMessages.DestructureNamedImport);\n          }\n\n          this.expect(types.comma);\n          if (this.eat(types.braceR)) break;\n        }\n\n        this.parseImportSpecifier(node);\n      }\n    }\n  }, {\n    key: \"parseImportSpecifier\",\n    value: function parseImportSpecifier(node) {\n      var specifier = this.startNode();\n      specifier.imported = this.parseIdentifier(true);\n\n      if (this.eatContextual(\"as\")) {\n        specifier.local = this.parseIdentifier();\n      } else {\n        this.checkReservedWord(specifier.imported.name, specifier.start, true, true);\n        specifier.local = specifier.imported.__clone();\n      }\n\n      this.checkLVal(specifier.local, BIND_LEXICAL, undefined, \"import specifier\");\n      node.specifiers.push(this.finishNode(specifier, \"ImportSpecifier\"));\n    }\n  }]);\n\n  return StatementParser;\n}(ExpressionParser);\n\nvar ClassScope = function ClassScope() {\n  _classCallCheck(this, ClassScope);\n\n  this.privateNames = new Set();\n  this.loneAccessors = new Map();\n  this.undefinedPrivateNames = new Map();\n};\n\nvar ClassScopeHandler = /*#__PURE__*/function () {\n  function ClassScopeHandler(raise) {\n    _classCallCheck(this, ClassScopeHandler);\n\n    this.stack = [];\n    this.undefinedPrivateNames = new Map();\n    this.raise = raise;\n  }\n\n  _createClass(ClassScopeHandler, [{\n    key: \"current\",\n    value: function current() {\n      return this.stack[this.stack.length - 1];\n    }\n  }, {\n    key: \"enter\",\n    value: function enter() {\n      this.stack.push(new ClassScope());\n    }\n  }, {\n    key: \"exit\",\n    value: function exit() {\n      var oldClassScope = this.stack.pop();\n      var current = this.current();\n\n      for (var _i = 0, _Array$from = Array.from(oldClassScope.undefinedPrivateNames); _i < _Array$from.length; _i++) {\n        var _Array$from$_i2 = _slicedToArray(_Array$from[_i], 2),\n            name = _Array$from$_i2[0],\n            pos = _Array$from$_i2[1];\n\n        if (current) {\n          if (!current.undefinedPrivateNames.has(name)) {\n            current.undefinedPrivateNames.set(name, pos);\n          }\n        } else {\n          this.raise(pos, ErrorMessages.InvalidPrivateFieldResolution, name);\n        }\n      }\n    }\n  }, {\n    key: \"declarePrivateName\",\n    value: function declarePrivateName(name, elementType, pos) {\n      var classScope = this.current();\n      var redefined = classScope.privateNames.has(name);\n\n      if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {\n        var accessor = redefined && classScope.loneAccessors.get(name);\n\n        if (accessor) {\n          var oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;\n          var newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;\n          var oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;\n          var newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;\n          redefined = oldKind === newKind || oldStatic !== newStatic;\n          if (!redefined) classScope.loneAccessors.delete(name);\n        } else if (!redefined) {\n          classScope.loneAccessors.set(name, elementType);\n        }\n      }\n\n      if (redefined) {\n        this.raise(pos, ErrorMessages.PrivateNameRedeclaration, name);\n      }\n\n      classScope.privateNames.add(name);\n      classScope.undefinedPrivateNames.delete(name);\n    }\n  }, {\n    key: \"usePrivateName\",\n    value: function usePrivateName(name, pos) {\n      var classScope;\n\n      for (var _i2 = 0, _this$stack = this.stack; _i2 < _this$stack.length; _i2++) {\n        classScope = _this$stack[_i2];\n        if (classScope.privateNames.has(name)) return;\n      }\n\n      if (classScope) {\n        classScope.undefinedPrivateNames.set(name, pos);\n      } else {\n        this.raise(pos, ErrorMessages.InvalidPrivateFieldResolution, name);\n      }\n    }\n  }]);\n\n  return ClassScopeHandler;\n}();\n\nvar Parser = /*#__PURE__*/function (_StatementParser) {\n  _inherits(Parser, _StatementParser);\n\n  var _super17 = _createSuper(Parser);\n\n  function Parser(options, input) {\n    var _this49;\n\n    _classCallCheck(this, Parser);\n\n    options = getOptions(options);\n    _this49 = _super17.call(this, options, input);\n\n    var ScopeHandler = _this49.getScopeHandler();\n\n    _this49.options = options;\n    _this49.inModule = _this49.options.sourceType === \"module\";\n    _this49.scope = new ScopeHandler(_this49.raise.bind(_assertThisInitialized(_this49)), _this49.inModule);\n    _this49.prodParam = new ProductionParameterHandler();\n    _this49.classScope = new ClassScopeHandler(_this49.raise.bind(_assertThisInitialized(_this49)));\n    _this49.plugins = pluginsMap(_this49.options.plugins);\n    _this49.filename = options.sourceFilename;\n    return _this49;\n  }\n\n  _createClass(Parser, [{\n    key: \"getScopeHandler\",\n    value: function getScopeHandler() {\n      return ScopeHandler;\n    }\n  }, {\n    key: \"parse\",\n    value: function parse() {\n      var paramFlags = PARAM;\n\n      if (this.hasPlugin(\"topLevelAwait\") && this.inModule) {\n        paramFlags |= PARAM_AWAIT;\n      }\n\n      this.scope.enter(SCOPE_PROGRAM);\n      this.prodParam.enter(paramFlags);\n      var file = this.startNode();\n      var program = this.startNode();\n      this.nextToken();\n      file.errors = null;\n      this.parseTopLevel(file, program);\n      file.errors = this.state.errors;\n      return file;\n    }\n  }]);\n\n  return Parser;\n}(StatementParser);\n\nfunction pluginsMap(plugins) {\n  var pluginMap = new Map();\n\n  for (var _i = 0; _i < plugins.length; _i++) {\n    var plugin = plugins[_i];\n\n    var _ref15 = Array.isArray(plugin) ? plugin : [plugin, {}],\n        _ref16 = _slicedToArray(_ref15, 2),\n        name = _ref16[0],\n        options = _ref16[1];\n\n    if (!pluginMap.has(name)) pluginMap.set(name, options || {});\n  }\n\n  return pluginMap;\n}\n\nfunction parse(input, options) {\n  var _options;\n\n  if (((_options = options) == null ? void 0 : _options.sourceType) === \"unambiguous\") {\n    options = Object.assign({}, options);\n\n    try {\n      options.sourceType = \"module\";\n      var parser = getParser(options, input);\n      var ast = parser.parse();\n\n      if (parser.sawUnambiguousESM) {\n        return ast;\n      }\n\n      if (parser.ambiguousScriptDifferentAst) {\n        try {\n          options.sourceType = \"script\";\n          return getParser(options, input).parse();\n        } catch (_unused) {}\n      } else {\n        ast.program.sourceType = \"script\";\n      }\n\n      return ast;\n    } catch (moduleError) {\n      try {\n        options.sourceType = \"script\";\n        return getParser(options, input).parse();\n      } catch (_unused2) {}\n\n      throw moduleError;\n    }\n  } else {\n    return getParser(options, input).parse();\n  }\n}\n\nfunction parseExpression(input, options) {\n  var parser = getParser(options, input);\n\n  if (parser.options.strictMode) {\n    parser.state.strict = true;\n  }\n\n  return parser.getExpression();\n}\n\nfunction getParser(options, input) {\n  var cls = Parser;\n\n  if (options == null ? void 0 : options.plugins) {\n    validatePlugins(options.plugins);\n    cls = getParserClass(options.plugins);\n  }\n\n  return new cls(options, input);\n}\n\nvar parserClassCache = {};\n\nfunction getParserClass(pluginsFromOptions) {\n  var pluginList = mixinPluginNames.filter(function (name) {\n    return hasPlugin(pluginsFromOptions, name);\n  });\n  var key = pluginList.join(\"/\");\n  var cls = parserClassCache[key];\n\n  if (!cls) {\n    cls = Parser;\n\n    for (var _i = 0; _i < pluginList.length; _i++) {\n      var plugin = pluginList[_i];\n      cls = mixinPlugins[plugin](cls);\n    }\n\n    parserClassCache[key] = cls;\n  }\n\n  return cls;\n}\n\nexports.parse = parse;\nexports.parseExpression = parseExpression;\nexports.tokTypes = types;"],"sourceRoot":""}